{"Address.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     *\n     * Furthermore, `isContract` will also return true if the target contract within\n     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n     * which only has an effect at the end of a transaction.\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn\u0027t rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length \u003e 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity\u0027s `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance \u003e= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance \u003e= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn\u0027t, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length \u003e 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n"},"Asakusa.sol":{"content":"// SPDX-License-Identifier: MIT\r\n\r\npragma solidity ^0.8.0;\r\n\r\nimport \"./Context.sol\";\r\nimport \"./Address.sol\";\r\nimport \"./Ownable.sol\";\r\nimport \"./IERC20.sol\";\r\n\r\nimport \"./IUniswapV2Factory.sol\";\r\nimport \"./IUniswapV2Pair.sol\";\r\nimport \"./IUniswapV2Router01.sol\";\r\nimport \"./IUniswapV2Router02.sol\";\r\n\r\n\r\n/*\r\n * @author ~ ?????? ~ (https://twitter.com/Xipzer | https://t.me/Xipzer)\r\n *\r\n * ░█████╗░░██████╗░█████╗░██╗░░██╗██╗░░░██╗░██████╗░█████╗░\r\n * ██╔══██╗██╔════╝██╔══██╗██║░██╔╝██║░░░██║██╔════╝██╔══██╗\r\n * ███████║╚█████╗░███████║█████═╝░██║░░░██║╚█████╗░███████║\r\n * ██╔══██║░╚═══██╗██╔══██║██╔═██╗░██║░░░██║░╚═══██╗██╔══██║\r\n * ██║░░██║██████╔╝██║░░██║██║░╚██╗╚██████╔╝██████╔╝██║░░██║\r\n * ╚═╝░░╚═╝╚═════╝░╚═╝░░╚═╝╚═╝░░╚═╝░╚═════╝░╚═════╝░╚═╝░░╚═╝\r\n *\r\n */\r\n\r\ncontract Asakusa is Context, IERC20, Ownable\r\n{\r\n    using Address for address;\r\n\r\n    string public name = \"Asakusa\";\r\n    string public symbol = \"ASAKUSA\";\r\n\r\n    uint public decimals = 18;\r\n    uint public totalSupply = 1000000000 * 10 ** decimals;\r\n\r\n    uint private maxTXN = (totalSupply * 15) / 1000;\r\n    uint private maxWallet = (totalSupply * 15) / 1000;\r\n    uint public swapThresholdMin = totalSupply / 5000;\r\n    uint public swapThresholdMax = totalSupply / 1000;\r\n\r\n    address public dexPair;\r\n    IUniswapV2Router02 public dexRouter;\r\n\r\n    address public constant DEAD = 0x000000000000000000000000000000000000dEaD;\r\n\r\n    mapping (address =\u003e uint) private balances;\r\n    mapping (address =\u003e mapping (address =\u003e uint)) private allowances;\r\n\r\n    mapping (address =\u003e bool) private isCaughtMEV;\r\n    mapping (address =\u003e bool) private isFeeExempt;\r\n    mapping (address =\u003e bool) private isTxnLimitExempt;\r\n    mapping (address =\u003e bool) private isWalletLimitExempt;\r\n    mapping (address =\u003e bool) public isMarketPair;\r\n\r\n    struct Fees\r\n    {\r\n        uint inFee;\r\n        uint outFee;\r\n        uint transferFee;\r\n    }\r\n\r\n    struct FeeSplit\r\n    {\r\n        uint marketing;\r\n        uint development;\r\n    }\r\n\r\n    struct FeeReceivers\r\n    {\r\n        address payable marketing;\r\n        address payable development;\r\n    }\r\n\r\n    Fees public fees;\r\n    FeeSplit public feeSplit;\r\n    FeeReceivers public feeReceivers;\r\n\r\n    bool public tradingEnabled;\r\n    bool public protectionRenounced;\r\n    bool public inSwapAndLiquify;\r\n    bool public swapAndLiquifyEnabled;\r\n    bool public swapAndLiquifyByLimitOnly;\r\n\r\n    event SwapAndLiquifyStatusUpdated(bool status);\r\n    event SwapAndLiquifyByLimitStatusUpdated(bool status);\r\n    event SwapTokensForETH(uint amountIn, address[] path);\r\n\r\n    modifier lockTheSwap\r\n    {\r\n        inSwapAndLiquify = true;\r\n        _;\r\n        inSwapAndLiquify = false;\r\n    }\r\n\r\n    constructor(address marketing, address development)\r\n    {\r\n        dexRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\r\n        dexPair = IUniswapV2Factory(dexRouter.factory()).createPair(address(this), dexRouter.WETH());\r\n\r\n        allowances[address(this)][address(dexRouter)] = type(uint).max;\r\n\r\n        fees.inFee = 1500;\r\n        fees.outFee = 3500;\r\n        fees.transferFee = 3500;\r\n\r\n        feeReceivers.marketing = payable(marketing);\r\n        feeReceivers.development = payable(development);\r\n\r\n        feeSplit.marketing = 6000;\r\n        feeSplit.development = 4000;\r\n\r\n        isFeeExempt[owner()] = true;\r\n        isFeeExempt[address(0)] = true;\r\n        isFeeExempt[DEAD] = true;\r\n        isFeeExempt[address(this)] = true;\r\n        isFeeExempt[feeReceivers.marketing] = true;\r\n        isFeeExempt[feeReceivers.development] = true;\r\n\r\n        isTxnLimitExempt[owner()] = true;\r\n        isTxnLimitExempt[address(0)] = true;\r\n        isTxnLimitExempt[DEAD] = true;\r\n        isTxnLimitExempt[address(this)] = true;\r\n        isTxnLimitExempt[feeReceivers.marketing] = true;\r\n        isTxnLimitExempt[feeReceivers.development] = true;\r\n\r\n        isWalletLimitExempt[owner()] = true;\r\n        isWalletLimitExempt[address(0)] = true;\r\n        isWalletLimitExempt[DEAD] = true;\r\n        isWalletLimitExempt[address(this)] = true;\r\n        isWalletLimitExempt[feeReceivers.marketing] = true;\r\n        isWalletLimitExempt[feeReceivers.development] = true;\r\n\r\n        isWalletLimitExempt[address(dexPair)] = true;\r\n        isMarketPair[address(dexPair)] = true;\r\n\r\n        swapAndLiquifyEnabled = true;\r\n        swapAndLiquifyByLimitOnly = true;\r\n\r\n        balances[_msgSender()] = totalSupply;\r\n        emit Transfer(address(0), _msgSender(), totalSupply);\r\n    }\r\n\r\n    function balanceOf(address wallet) public view override returns (uint)\r\n    {\r\n        return balances[wallet];\r\n    }\r\n\r\n    function allowance(address owner, address spender) public view override returns (uint)\r\n    {\r\n        return allowances[owner][spender];\r\n    }\r\n\r\n    function getCirculatingSupply() public view returns (uint)\r\n    {\r\n        return totalSupply - balanceOf(address(0)) - balanceOf(DEAD);\r\n    }\r\n\r\n    function getMEVStatus(address wallet) public view returns (bool)\r\n    {\r\n        return isCaughtMEV[wallet];\r\n    }\r\n\r\n    function setWalletFeeStatus(address wallet, bool status) public onlyOwner()\r\n    {\r\n        isFeeExempt[wallet] = status;\r\n    }\r\n\r\n    function setWalletTxnStatus(address wallet, bool status) public onlyOwner()\r\n    {\r\n        isTxnLimitExempt[wallet] = status;\r\n    }\r\n\r\n    function setWalletLimitStatus(address wallet, bool status) public onlyOwner()\r\n    {\r\n        isWalletLimitExempt[wallet] = status;\r\n    }\r\n\r\n    function setMarketPairStatus(address wallet, bool status) public onlyOwner()\r\n    {\r\n        isMarketPair[wallet] = status;\r\n    }\r\n\r\n    function setMaxTXN(uint value) public onlyOwner()\r\n    {\r\n        require(value \u003e= totalSupply / 10000, \"ERROR: Minimum txn must be greater than 0.01% of total supply!\");\r\n\r\n        maxTXN = value;\r\n    }\r\n\r\n    function setMaxWallet(uint value) public onlyOwner()\r\n    {\r\n        require(value \u003e= totalSupply / 10000, \"ERROR: Minimum wallet size must be greater than 0.01% of total supply!\");\r\n\r\n        maxWallet = value;\r\n    }\r\n\r\n    function enableTrading() public onlyOwner()\r\n    {\r\n        require(!tradingEnabled, \"ERROR: Trading is already enabled!\");\r\n        tradingEnabled = true;\r\n    }\r\n\r\n    function removeMaxTXN() public onlyOwner()\r\n    {\r\n        maxTXN = totalSupply;\r\n    }\r\n\r\n    function removeMaxWallet() public onlyOwner()\r\n    {\r\n        maxWallet = totalSupply;\r\n    }\r\n\r\n    function renounceMEVProtection() public onlyOwner()\r\n    {\r\n        require(!protectionRenounced, \"ERROR: Anti-MEV system is already renounced!\");\r\n        protectionRenounced = true;\r\n    }\r\n\r\n    function setCaughtMEV(address[] memory wallets, bool status) public onlyOwner()\r\n    {\r\n        require(!protectionRenounced, \"ERROR: Anti-MEV system is permanently disabled!\");\r\n        require(wallets.length \u003c= 200, \"ERROR: Maximum wallets at once is 200!\");\r\n\r\n        for (uint i = 0; i \u003c wallets.length; i++)\r\n            isCaughtMEV[wallets[i]] = status;\r\n    }\r\n\r\n    function setFees(uint inFee, uint outFee, uint transferFee) public onlyOwner()\r\n    {\r\n        require(inFee \u003c= 5000 \u0026\u0026 outFee \u003c= 5000 \u0026\u0026 transferFee \u003c= 5000, \"ERROR: Maximum directional fee is 50%!\");\r\n\r\n        fees.inFee = inFee;\r\n        fees.outFee = outFee;\r\n        fees.transferFee = transferFee;\r\n    }\r\n\r\n    function setFeeSplit(uint marketing, uint development) public onlyOwner()\r\n    {\r\n        require(marketing \u003c= 10000 \u0026\u0026 development \u003c= 10000, \"ERROR: Fee split must not exceed 100%!\");\r\n        require(marketing + development \u003c= 10000, \"ERROR: Combined fee must not exceed 100%!\");\r\n\r\n        feeSplit.marketing = marketing;\r\n        feeSplit.development = development;\r\n    }\r\n\r\n    function setFeeReceivers(address marketing, address development) public onlyOwner()\r\n    {\r\n        require(marketing != address(0) \u0026\u0026 development != address(0), \"ERROR: Fee receiver must not be NULL address!\");\r\n\r\n        isFeeExempt[feeReceivers.marketing] = false;\r\n        isFeeExempt[feeReceivers.development] = false;\r\n\r\n        feeReceivers.marketing = payable(marketing);\r\n        feeReceivers.development = payable(development);\r\n\r\n        isFeeExempt[feeReceivers.marketing] = true;\r\n        isFeeExempt[feeReceivers.development] = true;\r\n    }\r\n\r\n    function setSwapThresholds(uint swapMin, uint swapMax) public onlyOwner()\r\n    {\r\n        swapThresholdMin = swapMin;\r\n        swapThresholdMax = swapMax;\r\n    }\r\n\r\n    function setSwapAndLiquifyStatus(bool status) public onlyOwner()\r\n    {\r\n        swapAndLiquifyEnabled = status;\r\n        emit SwapAndLiquifyStatusUpdated(status);\r\n    }\r\n\r\n    function setSwapAndLiquifyByLimitStatus(bool status) public onlyOwner()\r\n    {\r\n        swapAndLiquifyByLimitOnly = status;\r\n        emit SwapAndLiquifyByLimitStatusUpdated(status);\r\n    }\r\n\r\n    function approve(address spender, uint amount) public override returns (bool)\r\n    {\r\n        _approve(_msgSender(), spender, amount);\r\n        return true;\r\n    }\r\n\r\n    function _approve(address owner, address spender, uint amount) private\r\n    {\r\n        require(owner != address(0), \"ERROR: Approve from the zero address!\");\r\n        require(spender != address(0), \"ERROR: Approve to the zero address!\");\r\n\r\n        allowances[owner][spender] = amount;\r\n        emit Approval(owner, spender, amount);\r\n    }\r\n\r\n    function transfer(address recipient, uint amount) public override returns (bool)\r\n    {\r\n        _transfer(_msgSender(), recipient, amount);\r\n        return true;\r\n    }\r\n\r\n    function transferFrom(address sender, address recipient, uint amount) public override returns (bool)\r\n    {\r\n        if (allowances[sender][_msgSender()] != type(uint256).max)\r\n            allowances[sender][_msgSender()] -= amount;\r\n\r\n        return _transfer(sender, recipient, amount);\r\n    }\r\n\r\n    function transferToAddressNative(address payable recipient, uint amount) private\r\n    {\r\n        require(recipient != address(0), \"SolarGuard: Cannot send to the 0 address!\");\r\n\r\n        recipient.call{ value: amount }(\"\");\r\n    }\r\n\r\n    function _transfer(address sender, address recipient, uint amount) private returns (bool)\r\n    {\r\n        require(sender != address(0), \"ERROR: Transfer from the zero address!\");\r\n        require(recipient != address(0), \"ERROR: Transfer to the zero address!\");\r\n        require(!isCaughtMEV[recipient] \u0026\u0026 !isCaughtMEV[sender], \"ERROR: Transfers are not permitted!\");\r\n\r\n        if (inSwapAndLiquify)\r\n        {\r\n            unchecked\r\n            {\r\n                require(amount \u003c= balances[sender], \"ERROR: Insufficient balance!\");\r\n                balances[sender] -= amount;\r\n            }\r\n\r\n            balances[recipient] += amount;\r\n\r\n            emit Transfer(sender, recipient, amount);\r\n            return true;\r\n        }\r\n        else\r\n        {\r\n            if (!isFeeExempt[sender] \u0026\u0026 !isFeeExempt[recipient])\r\n                require(tradingEnabled, \"ERROR: Trading has not yet been enabled!\");\r\n\r\n            if (!isTxnLimitExempt[sender] \u0026\u0026 !isTxnLimitExempt[recipient])\r\n                require(amount \u003c= maxTXN, \"ERROR: Transfer amount exceeds the maxTXN!\");\r\n\r\n            uint contractTokenBalance = balanceOf(address(this));\r\n            if (!inSwapAndLiquify \u0026\u0026 swapAndLiquifyEnabled \u0026\u0026 !isMarketPair[sender] \u0026\u0026 contractTokenBalance \u003e= swapThresholdMin)\r\n            {\r\n                if (swapAndLiquifyByLimitOnly)\r\n                    contractTokenBalance = min(amount, min(contractTokenBalance, swapThresholdMax));\r\n\r\n                swapAndLiquify(contractTokenBalance);\r\n            }\r\n\r\n            unchecked\r\n            {\r\n                require(amount \u003c= balances[sender], \"ERROR: Insufficient balance!\");\r\n                balances[sender] -= amount;\r\n            }\r\n\r\n            uint finalAmount = (isFeeExempt[sender] || isFeeExempt[recipient]) ? amount : takeFee(sender, recipient, amount);\r\n\r\n            if (!isWalletLimitExempt[recipient])\r\n                require(balanceOf(recipient) + finalAmount \u003c= maxWallet, \"ERROR: Transfer amount must not exceed max wallet conditions!\");\r\n\r\n            balances[recipient] += finalAmount;\r\n\r\n            emit Transfer(sender, recipient, finalAmount);\r\n            return true;\r\n        }\r\n    }\r\n\r\n    function swapAndLiquify(uint amount) private lockTheSwap\r\n    {\r\n        swapTokensForETH(amount);\r\n        uint amountReceived = address(this).balance;\r\n\r\n        uint marketingAmount = (amountReceived * feeSplit.marketing) / 10000;\r\n        uint developmentAmount = (amountReceived * feeSplit.development) / 10000;\r\n\r\n        if (marketingAmount \u003e 0)\r\n            transferToAddressNative(feeReceivers.marketing, marketingAmount);\r\n        if (developmentAmount \u003e 0)\r\n            transferToAddressNative(feeReceivers.development, developmentAmount);\r\n    }\r\n\r\n    function swapTokensForETH(uint amount) private\r\n    {\r\n        address[] memory path = new address[](2);\r\n        path[0] = address(this);\r\n        path[1] = dexRouter.WETH();\r\n\r\n        try dexRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(amount, 0, path, address(this), block.timestamp)\r\n        {\r\n            emit SwapTokensForETH(amount, path);\r\n        }\r\n        catch\r\n        {\r\n            return;\r\n        }\r\n    }\r\n\r\n    function takeFee(address sender, address recipient, uint amount) internal returns (uint)\r\n    {\r\n        uint feeAmount = 0;\r\n\r\n        if (isMarketPair[sender])\r\n            feeAmount = (amount * fees.inFee) / 10000;\r\n        else if (isMarketPair[recipient])\r\n            feeAmount = (amount * fees.outFee) / 10000;\r\n        else\r\n            feeAmount = (amount * fees.transferFee) / 10000;\r\n\r\n        if (feeAmount \u003e 0)\r\n        {\r\n            balances[address(this)] += feeAmount;\r\n            emit Transfer(sender, address(this), feeAmount);\r\n        }\r\n\r\n        return amount - feeAmount;\r\n    }\r\n\r\n    function withdrawStuckNative(address recipient, uint amount) public onlyOwner()\r\n    {\r\n        require(recipient != address(0), \"ERROR: Cannot send to the 0 address!\");\r\n        payable(recipient).transfer(amount);\r\n    }\r\n\r\n    function withdrawForeignToken(address tokenAddress, address recipient, uint amount) public onlyOwner()\r\n    {\r\n        require(recipient != address(0), \"ERROR: Cannot send to the 0 address!\");\r\n        IERC20(tokenAddress).transfer(recipient, amount);\r\n    }\r\n\r\n    function min(uint a, uint b) private pure returns (uint)\r\n    {\r\n        return (a \u003e= b) ? b : a;\r\n    }\r\n\r\n    receive() external payable {}\r\n}"},"Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n}\n"},"IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller\u0027s account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller\u0027s tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender\u0027s allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `from` to `to` using the\n     * allowance mechanism. `amount` is then deducted from the caller\u0027s\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n"},"IUniswapV2Factory.sol":{"content":"pragma solidity \u003e=0.5.0;\n\ninterface IUniswapV2Factory {\n    event PairCreated(address indexed token0, address indexed token1, address pair, uint);\n\n    function feeTo() external view returns (address);\n    function feeToSetter() external view returns (address);\n\n    function getPair(address tokenA, address tokenB) external view returns (address pair);\n    function allPairs(uint) external view returns (address pair);\n    function allPairsLength() external view returns (uint);\n\n    function createPair(address tokenA, address tokenB) external returns (address pair);\n\n    function setFeeTo(address) external;\n    function setFeeToSetter(address) external;\n}\n"},"IUniswapV2Pair.sol":{"content":"pragma solidity \u003e=0.5.0;\n\ninterface IUniswapV2Pair {\n    event Approval(address indexed owner, address indexed spender, uint value);\n    event Transfer(address indexed from, address indexed to, uint value);\n\n    function name() external pure returns (string memory);\n    function symbol() external pure returns (string memory);\n    function decimals() external pure returns (uint8);\n    function totalSupply() external view returns (uint);\n    function balanceOf(address owner) external view returns (uint);\n    function allowance(address owner, address spender) external view returns (uint);\n\n    function approve(address spender, uint value) external returns (bool);\n    function transfer(address to, uint value) external returns (bool);\n    function transferFrom(address from, address to, uint value) external returns (bool);\n\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n    function PERMIT_TYPEHASH() external pure returns (bytes32);\n    function nonces(address owner) external view returns (uint);\n\n    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;\n\n    event Mint(address indexed sender, uint amount0, uint amount1);\n    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);\n    event Swap(\n        address indexed sender,\n        uint amount0In,\n        uint amount1In,\n        uint amount0Out,\n        uint amount1Out,\n        address indexed to\n    );\n    event Sync(uint112 reserve0, uint112 reserve1);\n\n    function MINIMUM_LIQUIDITY() external pure returns (uint);\n    function factory() external view returns (address);\n    function token0() external view returns (address);\n    function token1() external view returns (address);\n    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);\n    function price0CumulativeLast() external view returns (uint);\n    function price1CumulativeLast() external view returns (uint);\n    function kLast() external view returns (uint);\n\n    function mint(address to) external returns (uint liquidity);\n    function burn(address to) external returns (uint amount0, uint amount1);\n    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;\n    function skim(address to) external;\n    function sync() external;\n\n    function initialize(address, address) external;\n}\n"},"IUniswapV2Router01.sol":{"content":"pragma solidity \u003e=0.6.2;\n\ninterface IUniswapV2Router01 {\n    function factory() external pure returns (address);\n    function WETH() external pure returns (address);\n\n    function addLiquidity(\n        address tokenA,\n        address tokenB,\n        uint amountADesired,\n        uint amountBDesired,\n        uint amountAMin,\n        uint amountBMin,\n        address to,\n        uint deadline\n    ) external returns (uint amountA, uint amountB, uint liquidity);\n    function addLiquidityETH(\n        address token,\n        uint amountTokenDesired,\n        uint amountTokenMin,\n        uint amountETHMin,\n        address to,\n        uint deadline\n    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);\n    function removeLiquidity(\n        address tokenA,\n        address tokenB,\n        uint liquidity,\n        uint amountAMin,\n        uint amountBMin,\n        address to,\n        uint deadline\n    ) external returns (uint amountA, uint amountB);\n    function removeLiquidityETH(\n        address token,\n        uint liquidity,\n        uint amountTokenMin,\n        uint amountETHMin,\n        address to,\n        uint deadline\n    ) external returns (uint amountToken, uint amountETH);\n    function removeLiquidityWithPermit(\n        address tokenA,\n        address tokenB,\n        uint liquidity,\n        uint amountAMin,\n        uint amountBMin,\n        address to,\n        uint deadline,\n        bool approveMax, uint8 v, bytes32 r, bytes32 s\n    ) external returns (uint amountA, uint amountB);\n    function removeLiquidityETHWithPermit(\n        address token,\n        uint liquidity,\n        uint amountTokenMin,\n        uint amountETHMin,\n        address to,\n        uint deadline,\n        bool approveMax, uint8 v, bytes32 r, bytes32 s\n    ) external returns (uint amountToken, uint amountETH);\n    function swapExactTokensForTokens(\n        uint amountIn,\n        uint amountOutMin,\n        address[] calldata path,\n        address to,\n        uint deadline\n    ) external returns (uint[] memory amounts);\n    function swapTokensForExactTokens(\n        uint amountOut,\n        uint amountInMax,\n        address[] calldata path,\n        address to,\n        uint deadline\n    ) external returns (uint[] memory amounts);\n    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)\n        external\n        payable\n        returns (uint[] memory amounts);\n    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)\n        external\n        returns (uint[] memory amounts);\n    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)\n        external\n        returns (uint[] memory amounts);\n    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)\n        external\n        payable\n        returns (uint[] memory amounts);\n\n    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);\n    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);\n    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);\n    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);\n    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);\n}\n"},"IUniswapV2Router02.sol":{"content":"pragma solidity \u003e=0.6.2;\n\nimport \u0027./IUniswapV2Router01.sol\u0027;\n\ninterface IUniswapV2Router02 is IUniswapV2Router01 {\n    function removeLiquidityETHSupportingFeeOnTransferTokens(\n        address token,\n        uint liquidity,\n        uint amountTokenMin,\n        uint amountETHMin,\n        address to,\n        uint deadline\n    ) external returns (uint amountETH);\n    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(\n        address token,\n        uint liquidity,\n        uint amountTokenMin,\n        uint amountETHMin,\n        address to,\n        uint deadline,\n        bool approveMax, uint8 v, bytes32 r, bytes32 s\n    ) external returns (uint amountETH);\n\n    function swapExactTokensForTokensSupportingFeeOnTransferTokens(\n        uint amountIn,\n        uint amountOutMin,\n        address[] calldata path,\n        address to,\n        uint deadline\n    ) external;\n    function swapExactETHForTokensSupportingFeeOnTransferTokens(\n        uint amountOutMin,\n        address[] calldata path,\n        address to,\n        uint deadline\n    ) external payable;\n    function swapExactTokensForETHSupportingFeeOnTransferTokens(\n        uint amountIn,\n        uint amountOutMin,\n        address[] calldata path,\n        address to,\n        uint deadline\n    ) external;\n}\n"},"Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"}}