pragma solidity ^0.8.12;

//SPDX-License-Identifier: MIT

/**
 * @title Proxy
 * @dev Implements delegation of calls to other contracts, with proper
 * forwarding of return values and bubbling of failures.
 * It defines a fallback function that delegates all calls to the address
 * returned by the abstract _implementation() internal function.
 */
abstract contract Proxy {
    /**
     * @dev Fallback function.
     * Implemented entirely in `_fallback`.
     */
    fallback() external payable {
        _fallback();
    }

    receive() external payable {
        _fallback();
    }

    /**
     * @return The Address of the implementation.
     */
    function _implementation() internal view virtual returns (address);

    /**
     * @dev Delegates execution to an implementation contract.
     * This is a low level function that doesn't return to its internal call site.
     * It will return to the external caller whatever the implementation returns.
     * @param implementation Address to delegate.
     */
    function _delegate(address implementation) internal {
        assembly {
            // Copy msg.data. We take full control of memory in this inline assembly
            // block because it will not return to Solidity code. We overwrite the
            // Solidity scratch pad at memory position 0.
            calldatacopy(0, 0, calldatasize())

            // Call the implementation.
            // out and outsize are 0 because we don't know the size yet.
            let result := delegatecall(
                gas(),
                implementation,
                0,
                calldatasize(),
                0,
                0
            )
            // Copy the returned data.
            let retSz := returndatasize()
            returndatacopy(0, 0, retSz)

            switch result
            // delegatecall returns 0 on error.
            case 0 {
                revert(0, retSz)
            }
            default {
                return(0, retSz)
            }
        }
    }

    /**
     * @dev Function that is run as the first thing in the fallback function.
     * Can be redefined in derived contracts to add functionality.
     * Redefinitions must call super._beforeFallback().
     */
    function _beforeFallback() internal virtual {}

    /**
     * @dev fallback implementation.
     * Extracted to enable manual triggering.
     */
    function _fallback() internal {
        _beforeFallback();
        _delegate(_implementation());
    }
}

/**
 * Utility library of inline functions on addresses
 *
 * Source https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-solidity/v2.1.3/contracts/utils/Address.sol
 * This contract is copied here and renamed from the original to avoid clashes in the compiled artifacts
 * when the user imports a zos-lib contract (that transitively causes this contract to be compiled and added to the
 * build/artifacts folder) as well as the vanilla Address implementation from an openzeppelin version.
 */
library ZOSLibAddress {
    /**
     * Returns whether the target address is a contract
     * @dev This function will return false if invoked during the constructor of a contract,
     * as the code is not actually created until after the constructor finishes.
     * @param account address of the account to check
     * @return whether the target address is a contract
     */
    function isContract(address account) internal view returns (bool) {
        uint256 size;
        // XXX Currently there is no better way to check if there is a contract in an address
        // than to check the size of the code at that address.
        // See https://ethereum.stackexchange.com/a/14016/36603
        // for more details about how this works.
        // TODO Check this again before the Serenity release, because all addresses will be
        // contracts then.
        // solhint-disable-next-line no-inline-assembly
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }
}

/**
 * @title BaseUpgradeabilityProxy
 * @dev This contract implements a proxy that allows to change the
 * implementation address to which it will delegate.
 * Such a change is called an implementation upgrade.
 */
contract BaseUpgradeabilityProxy is Proxy {
    /**
     * @dev Emitted when the implementation is upgraded.
     * @param implementation Address of the new implementation.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation", and is
     * validated in the constructor.
     */
    bytes32 internal constant IMPLEMENTATION_SLOT =
        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev Returns the current implementation.
     * @return impl Address of the current implementation
     */
    function _implementation() internal view override returns (address impl) {
        bytes32 slot = IMPLEMENTATION_SLOT;
        assembly {
            impl := sload(slot)
        }
    }

    /**
     * @dev Upgrades the proxy to a new implementation.
     * @param newImplementation Address of the new implementation.
     */
    function _upgradeTo(address newImplementation) internal {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    /**
     * @dev Sets the implementation address of the proxy.
     * @param newImplementation Address of the new implementation.
     */
    function _setImplementation(address newImplementation) internal {
        require(
            ZOSLibAddress.isContract(newImplementation),
            "Cannot set a proxy implementation to a non-contract address"
        );

        bytes32 slot = IMPLEMENTATION_SLOT;

        assembly {
            sstore(slot, newImplementation)
        }
    }
}


/**
 * @title BaseAdminUpgradeabilityProxy
 * @dev This contract combines an upgradeability proxy with an authorization
 * mechanism for administrative tasks.
 * All external functions in this contract must be guarded by the
 * `ifAdmin` modifier. See ethereum/solidity#3864 for a Solidity
 * feature proposal that would enable this to be done automatically.
 */
contract TransparentUpgradeableProxy is BaseUpgradeabilityProxy {
    //ERC-1967 bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)
    bytes32 internal constant ADMIN_SLOT =
        0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Contract constructor.
     * @param logic Address of the initial implementation.
     * @param newAdmin Admin of the proxy contract
     * @param data Data to send as msg.data to the implementation to initialize the proxied contract.
     * It should include the signature and the parameters of the function to be called, as described in
     * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
     * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped.
     */
    constructor(address logic, address newAdmin, bytes memory data) payable {
        assert(IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
        assert(ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
        _setAdmin(newAdmin);
        _setImplementation(logic);
        if (data.length > 0) {
            (bool success, ) = logic.delegatecall(data);
            require(success);
        }
    }

    /**
     * @dev Emitted when the administration has been transferred.
     * @param previousAdmin Address of the previous admin.
     * @param newAdmin Address of the new admin.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Modifier to check whether the `msg.sender` is the admin.
     * If it is, it will run the function. Otherwise, it will delegate the call
     * to the implementation.
     */
    modifier ifAdmin() {
        if (msg.sender == _admin()) {
            _;
        } else {
            _fallback();
        }
    }

    /**
     * @return The address of the proxy admin.
     */
    // function admin() external ifAdmin returns (address) { TODO
    function admin() external view returns (address) {
        return _admin();
    }

    /**
     * @return The address of the implementation.
     */
    // function implementation() external ifAdmin returns (address) { TODO
    function implementation() external view returns (address) {
        return _implementation();
    }

    /**
     * @dev Changes the admin of the proxy.
     * Only the current admin can call this function.
     * @param newAdmin Address to transfer proxy administration to.
     */
    function changeAdmin(address newAdmin) external ifAdmin {
        require(
            newAdmin != address(0),
            "Cannot change the admin of a proxy to the zero address"
        );
        emit AdminChanged(_admin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev Upgrade the backing implementation of the proxy.
     * Only the admin can call this function.
     * @param newImplementation Address of the new implementation.
     */
    function upgradeTo(address newImplementation) external ifAdmin {
        _upgradeTo(newImplementation);
    }

    /**
     * @dev Upgrade the backing implementation of the proxy and call a function
     * on the new implementation.
     * This is useful to initialize the proxied contract.
     * @param newImplementation Address of the new implementation.
     * @param data Data to send as msg.data in the low level call.
     * It should include the signature and the parameters of the function to be called, as described in
     * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
     */
    function upgradeToAndCall(address newImplementation, bytes calldata data)
        external
        payable
        ifAdmin
    {
        _upgradeTo(newImplementation);
        (bool success, ) = newImplementation.delegatecall(data);
        require(success);
    }

    /**
     * @return adm The admin slot.
     */
    function _admin() internal view returns (address adm) {
        bytes32 slot = ADMIN_SLOT;
        assembly {
            adm := sload(slot)
        }
    }

    /**
     * @dev Sets the address of the proxy admin.
     * @param newAdmin Address of the new proxy admin.
     */
    function _setAdmin(address newAdmin) internal {
        bytes32 slot = ADMIN_SLOT;

        assembly {
            sstore(slot, newAdmin)
        }
    }

    /**
     * @dev Only fall back when the sender is not the admin.
     */
    function _beforeFallback() internal override {
        require(
            msg.sender != _admin(),
            "Cannot call fallback function from the proxy admin"
        );
        super._beforeFallback();
    }
}

contract TransparentUpgradeableProxyImplementation is TransparentUpgradeableProxy {
    
    constructor(address logic, address admin, bytes memory data) TransparentUpgradeableProxy(logic, admin, data) {

    }
}

{"EGT.sol":{"content":"/*\r\n##########################################################################################################################\r\n##########################################################################################################################\r\n\r\nCopyright CryptIT GmbH\r\n\r\nLicensed under the Apache License, Version 2.0 (the \"License\");\r\nyou may not use this file except in compliance with the License.\r\nYou may obtain a copy of the License at\r\n\r\n    https://www.apache.org/licenses/LICENSE-2.0\r\n\r\nUnless required by applicable law or agreed to in writing, software\r\ndistributed under the License is distributed on an \"AS IS\" BASIS,\r\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\nSee the License for the specific language governing permissions and\r\nlimitations under the License.\r\n\r\n##########################################################################################################################\r\n##########################################################################################################################\r\n\r\n*/\r\nimport \"./Utils.sol\";\r\n\r\npragma solidity ^0.8.12;\r\n\r\n// SPDX-License-Identifier: Apache-2.0\r\n\r\ncontract EGT is Context, IERC20, AccessControl {\r\n    using SafeMath for uint256;\r\n    using Address for address;\r\n\r\n    bytes32 public constant ADMIN_AUTH = keccak256(\"ADMIN_AUTH\");\r\n    mapping(address =\u003e uint256) private _balances;\r\n    mapping(address =\u003e mapping(address =\u003e uint256)) private _allowances;\r\n    mapping(address =\u003e bool) private excludedFromFee;\r\n\r\n    string private _name;\r\n    string private _symbol;\r\n    uint256 private _totalSupply;\r\n    uint256 private _deltaLPReserve;\r\n\r\n    uint256 private _marketingShare;\r\n    uint256 private _buyBackShare;\r\n    uint256 private _devShare;\r\n    uint256 private _lpShare;\r\n\r\n    uint256 private _buyTax;\r\n    uint256 private _sellTax;\r\n\r\n    uint256 private _marketingTaxCollected;\r\n    uint256 private _buyBackTaxCollected;\r\n    uint256 private _developmentTaxCollected;\r\n    uint256 private _lpTaxCollected;\r\n\r\n    uint256 private minimumTokensValueBeforeSwap;\r\n    uint256 private minimumETHToTransfer;\r\n\r\n    uint256 private acceptSlippageReduceFactor;\r\n    uint256 private acceptFeeOnAddLP;\r\n\r\n    address payable public marketingAddress;\r\n    address payable public buyBackAddress;\r\n    address payable public developmentAddress;\r\n\r\n    IUniswapV2Router02 public uniswapV2Router;\r\n    address public uniswapV2Pair;\r\n    bool public enableUniSwap;\r\n\r\n    bool inSwapAndLiquify;\r\n    bool inSplitShares;\r\n    bool public swapAndLiquifyEnabled;\r\n    bool public autoSplitShares;\r\n    bool public taxesEnabled;\r\n\r\n    mapping(address =\u003e bool) private _lockedBot;\r\n\r\n    event SwapAndLiquifyEnabledUpdated(bool enabled);\r\n\r\n    event EnabledUniswap();\r\n    event UpdateOperationWallet(\r\n        address previousAddress,\r\n        address newAddress,\r\n        string operation\r\n    );\r\n\r\n    modifier lockForSwap() {\r\n        inSwapAndLiquify = true;\r\n        _;\r\n        inSwapAndLiquify = false;\r\n    }\r\n\r\n    modifier lockForSplitShare() {\r\n        inSplitShares = true;\r\n        _;\r\n        inSplitShares = false;\r\n    }\r\n\r\n    function initialize() external {\r\n        require(getRoleAdmin(ADMIN_AUTH) == 0x00, \"Invalid init\");\r\n\r\n        _setupRole(ADMIN_AUTH, _msgSender());\r\n        _setRoleAdmin(ADMIN_AUTH, ADMIN_AUTH);\r\n\r\n        _name = \"ElonGoat\";\r\n        _symbol = \"EGT\";\r\n        _totalSupply = 9 * 10**9 * 10**9;\r\n        _deltaLPReserve = 2 * 10**7 * 10**9;\r\n\r\n        _marketingShare = 40;\r\n        _buyBackShare = 20;\r\n        _devShare = 20;\r\n        _lpShare = 20;\r\n\r\n        _buyTax = 100;\r\n        _sellTax = 200;\r\n\r\n        _marketingTaxCollected;\r\n        _buyBackTaxCollected;\r\n        _developmentTaxCollected;\r\n        _lpTaxCollected;\r\n\r\n        minimumTokensValueBeforeSwap = 3 * 10**15;\r\n        minimumETHToTransfer = 1 * 10**16;\r\n\r\n        acceptSlippageReduceFactor = 7;\r\n        acceptFeeOnAddLP = 110;\r\n\r\n        swapAndLiquifyEnabled = true;\r\n        autoSplitShares = true;\r\n        enableUniSwap = false;\r\n        taxesEnabled = true;\r\n\r\n        uint256 initialBalance = _totalSupply.sub(_deltaLPReserve);\r\n        _balances[_msgSender()] = initialBalance;\r\n        _balances[address(this)] = _deltaLPReserve;\r\n        excludedFromFee[_msgSender()] = true;\r\n        excludedFromFee[address(this)] = true;\r\n        //UNISWAP V2\r\n        _setRouterAddress(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\r\n        _setOperatorsAddresses(\r\n            payable(0x4cC2B3336692E1EF68FA2381eb8c7fFa73B8f604),\r\n            payable(0x70fBFbA38623259c02167691B988235fbF40CC28),\r\n            payable(0xc0f4F07D5c1619d0237E2231703C30822A04E29C)\r\n        );\r\n\r\n        emit Transfer(address(0), _msgSender(), initialBalance);\r\n        emit Transfer(address(0), address(this), _deltaLPReserve);\r\n    }\r\n\r\n    // Start ERC-20 standard functions\r\n\r\n    function name() external view returns (string memory) {\r\n        return _name;\r\n    }\r\n\r\n    function symbol() external view returns (string memory) {\r\n        return _symbol;\r\n    }\r\n\r\n    function decimals() external pure returns (uint8) {\r\n        return 9;\r\n    }\r\n\r\n    function totalSupply() external view override returns (uint256) {\r\n        return _totalSupply;\r\n    }\r\n\r\n    function balanceOf(address account) public view override returns (uint256) {\r\n        return _balances[account];\r\n    }\r\n\r\n    function transfer(address recipient, uint256 amount)\r\n        public\r\n        override\r\n        returns (bool)\r\n    {\r\n        _transfer(_msgSender(), recipient, amount);\r\n        return true;\r\n    }\r\n\r\n    function allowance(address owner, address spender)\r\n        external\r\n        view\r\n        override\r\n        returns (uint256)\r\n    {\r\n        return _allowances[owner][spender];\r\n    }\r\n\r\n    function approve(address spender, uint256 amount)\r\n        external\r\n        override\r\n        returns (bool)\r\n    {\r\n        _approve(_msgSender(), spender, amount);\r\n        return true;\r\n    }\r\n\r\n    function transferFrom(\r\n        address sender,\r\n        address recipient,\r\n        uint256 amount\r\n    ) external override returns (bool) {\r\n        _transfer(sender, recipient, amount);\r\n        _approve(\r\n            sender,\r\n            _msgSender(),\r\n            _allowances[sender][_msgSender()].sub(\r\n                amount,\r\n                \"ERC20: transfer amount exceeds allowance\"\r\n            )\r\n        );\r\n        return true;\r\n    }\r\n\r\n    function increaseAllowance(address spender, uint256 addedValue)\r\n        external\r\n        virtual\r\n        returns (bool)\r\n    {\r\n        _approve(\r\n            _msgSender(),\r\n            spender,\r\n            _allowances[_msgSender()][spender].add(addedValue)\r\n        );\r\n        return true;\r\n    }\r\n\r\n    function decreaseAllowance(address spender, uint256 subtractedValue)\r\n        external\r\n        virtual\r\n        returns (bool)\r\n    {\r\n        _approve(\r\n            _msgSender(),\r\n            spender,\r\n            _allowances[_msgSender()][spender].sub(\r\n                subtractedValue,\r\n                \"ERC20: decreased allowance below zero\"\r\n            )\r\n        );\r\n        return true;\r\n    }\r\n\r\n    // End ERC-20 standart functions\r\n\r\n    function _approve(\r\n        address owner,\r\n        address spender,\r\n        uint256 amount\r\n    ) private {\r\n        require(owner != address(0), \"ERC20: approve from the zero address\");\r\n        require(spender != address(0), \"ERC20: 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(\r\n        address from,\r\n        address to,\r\n        uint256 amount\r\n    ) private {\r\n        require(from != address(0), \"ERC20: transfer from the zero address\");\r\n        require(to != address(0), \"ERC20: transfer to the zero address\");\r\n\r\n        require(!_lockedBot[from] \u0026\u0026 !_lockedBot[to], \"Invalid account - contact EGT admin!\");\r\n\r\n        if (amount == 0) {\r\n            emit Transfer(from, to, 0);\r\n            return;\r\n        }\r\n\r\n        if (!taxesEnabled || excludedFromFee[from] || excludedFromFee[to]) {\r\n            _transferStandard(from, to, amount);\r\n            return;\r\n        }\r\n\r\n        bool isToPair = to == uniswapV2Pair; //means sell or provide LP\r\n        bool isFromPair = from == uniswapV2Pair; //means buy or remove LP\r\n\r\n        if (!isToPair \u0026\u0026 !isFromPair) {\r\n            _transferStandard(from, to, amount);\r\n            return;\r\n        }\r\n\r\n        require(enableUniSwap, \"Uniswap not enabled yet\");\r\n\r\n        if (isToPair) {\r\n            _transferToPair(from, to, amount);\r\n        } else {\r\n            _transferFromPair(from, to, amount);\r\n        }\r\n\r\n        bool hasSwapped = false;\r\n        \r\n        if (!inSwapAndLiquify \u0026\u0026 !inSplitShares \u0026\u0026 swapAndLiquifyEnabled) {\r\n            uint256 contractTokenBalance = balanceOf(address(this)).sub(\r\n                _deltaLPReserve\r\n            );\r\n            uint256 contractTokenValue = getSellValue(contractTokenBalance);\r\n            if (contractTokenValue \u003e= minimumTokensValueBeforeSwap) {\r\n                swapAndLiquify(contractTokenBalance, contractTokenValue);\r\n                hasSwapped = true;\r\n            }\r\n        }\r\n        \r\n        //Check if we have ETH to split to receivers\r\n        if (\r\n            !hasSwapped \u0026\u0026\r\n            !inSplitShares \u0026\u0026\r\n            !inSwapAndLiquify \u0026\u0026\r\n            autoSplitShares \u0026\u0026\r\n            address(this).balance \u003e= minimumETHToTransfer\r\n        ) {\r\n            _distributeTax();\r\n        }\r\n    }\r\n    \r\n    function safeTransferETH(address to, uint256 value) internal {\r\n        (bool sentETH, ) = payable(to).call{value: value}(\"\");\r\n        require(sentETH, \"Failed to send ETH\");\r\n    }\r\n\r\n    function manualSwapAndLiquify() external onlyRole(ADMIN_AUTH) {\r\n        if (!inSwapAndLiquify \u0026\u0026 !inSplitShares) {\r\n            uint256 contractTokenBalance = balanceOf(address(this)).sub(\r\n                _deltaLPReserve\r\n            );\r\n            uint256 contractTokenValue = getSellValue(contractTokenBalance);\r\n            if (contractTokenValue \u003e= minimumTokensValueBeforeSwap) {\r\n                swapAndLiquify(contractTokenBalance, contractTokenValue);\r\n            }\r\n        }\r\n    }\r\n\r\n    function manualSwapAndLiquify(uint256 tokenAmountToSwap) external onlyRole(ADMIN_AUTH) {\r\n        if (!inSwapAndLiquify \u0026\u0026 !inSplitShares) {\r\n            uint256 contractTokenBalance = balanceOf(address(this)).sub(\r\n                _deltaLPReserve\r\n            );\r\n\r\n            require(contractTokenBalance \u003e= tokenAmountToSwap, \"Invalid amount\");\r\n\r\n            uint256 contractTokenValue = getSellValue(tokenAmountToSwap);\r\n            if (contractTokenValue \u003e= minimumTokensValueBeforeSwap) {\r\n                swapAndLiquify(tokenAmountToSwap, contractTokenValue);\r\n            }\r\n        }\r\n    }\r\n\r\n    function manualWithdrawTokens(uint256 tokenAmount) external onlyRole(ADMIN_AUTH) {\r\n        require(!inSwapAndLiquify \u0026\u0026 !inSplitShares, \"In autoswap\");\r\n\r\n        uint256 contractTokenBalance = balanceOf(address(this));\r\n\r\n        require(tokenAmount \u003c= contractTokenBalance, \"Invalid tokenamount\");\r\n\r\n        uint256 contractTokenBalanceSubDelta = contractTokenBalance.sub(\r\n            _deltaLPReserve\r\n        );\r\n\r\n        if(tokenAmount \u003e contractTokenBalanceSubDelta){\r\n            uint256 overBalanceAmount = tokenAmount.sub(contractTokenBalanceSubDelta);\r\n            _deltaLPReserve = _deltaLPReserve.sub(overBalanceAmount);\r\n        }\r\n\r\n        _transferStandard(address(this), _msgSender(), tokenAmount);\r\n    }\r\n\r\n    /**\r\n     * @dev Handles all autoswap to ETH\r\n     *\r\n     * @param tokensToSwap the amount that will be swapped\r\n     *\r\n     * NOTE: will never be called if swapAndLiquify = false!.\r\n     */\r\n    function swapAndLiquify(uint256 tokensToSwap, uint256 outAmount)\r\n        internal\r\n        lockForSwap\r\n    {\r\n        swapTokensForEth(\r\n            tokensToSwap,\r\n            outAmount.mul(acceptSlippageReduceFactor).div(10)\r\n        );\r\n    }\r\n\r\n    /**\r\n     * @dev Handles swaping tokens stored on the contract, half of the {amount} for ETH and adding it with the other hald of tokens to LP\r\n     *\r\n     * @param ETHAmount amount of ETH to provide LP for\r\n     * @return addedLP true on successful readd, false if not enought delta tokens\r\n     *\r\n     */\r\n    function reAddLiquidity(uint256 ETHAmount, uint256 tokenAmount)\r\n        internal\r\n        returns (bool)\r\n    {\r\n        uint256 amountToken = addLiquidity(tokenAmount, ETHAmount);\r\n\r\n        if (amountToken != 0) {\r\n            _deltaLPReserve = _deltaLPReserve.sub(amountToken);\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * @dev Handles add {tokenAmount} and {ETHAmount} to LP\r\n     *\r\n     * @param tokenAmount amount of tokens to be added to LP\r\n     * @param ETHAmount amount of ETH to be added to LP\r\n     *\r\n     * NOTE: LP tokens will be sent to the owner address.\r\n     *\r\n     */\r\n    function addLiquidity(uint256 tokenAmount, uint256 ETHAmount)\r\n        internal\r\n        returns (uint256)\r\n    {\r\n        _approve(address(this), address(uniswapV2Router), tokenAmount);\r\n\r\n        try\r\n            uniswapV2Router.addLiquidityETH{value: ETHAmount}(\r\n                address(this),\r\n                tokenAmount,\r\n                0,\r\n                0,\r\n                buyBackAddress,\r\n                block.timestamp\r\n            )\r\n        returns (uint256 amountToken, uint256, uint256) {\r\n            return amountToken;\r\n        } catch {\r\n            return 0;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Handles selling of {tokenAmount}\r\n     *\r\n     * @param tokenAmount the amount of tokens to swap for ETH\r\n     *\r\n     */\r\n    function swapTokensForEth(uint256 tokenAmount, uint256 expectedOutput)\r\n        internal\r\n    {\r\n        address[] memory path = new address[](2);\r\n        path[0] = address(this);\r\n        path[1] = uniswapV2Router.WETH();\r\n\r\n        _approve(address(this), address(uniswapV2Router), tokenAmount);\r\n        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(\r\n            tokenAmount,\r\n            expectedOutput,\r\n            path,\r\n            address(this),\r\n            block.timestamp\r\n        );\r\n    }\r\n\r\n    function getBuyValue(uint256 ETHAmount) internal view returns (uint256) {\r\n        address[] memory path = new address[](2);\r\n        path[0] = address(this);\r\n        path[1] = uniswapV2Router.WETH();\r\n        return uniswapV2Router.getAmountsIn(ETHAmount, path)[0];\r\n    }\r\n\r\n    function getSellValue(uint256 tokenAmount) internal view returns (uint256) {\r\n        address[] memory path = new address[](2);\r\n        path[0] = address(this);\r\n        path[1] = uniswapV2Router.WETH();\r\n        return uniswapV2Router.getAmountsOut(tokenAmount, path)[1];\r\n    }\r\n\r\n    function _distributeTax() internal lockForSplitShare {\r\n        uint256 total = address(this).balance;\r\n        uint256 mShare = total.mul(_marketingShare).div(100);\r\n        uint256 sShare = total.mul(_buyBackShare).div(100);\r\n        uint256 lpShare = total.mul(_lpShare).div(100);\r\n        uint256 tShare = total.sub(mShare).sub(sShare).sub(lpShare);\r\n\r\n        bool sentLP;\r\n        IUniswapV2Pair(uniswapV2Pair).sync();\r\n        uint256 tokenAmount = getBuyValue(lpShare).mul(acceptFeeOnAddLP).div(\r\n            100\r\n        );\r\n\r\n        if (_deltaLPReserve \u003c tokenAmount) {\r\n            tShare = tShare.add(lpShare);\r\n        } else {\r\n            sentLP = reAddLiquidity(lpShare, tokenAmount);\r\n\r\n            if (!sentLP) {\r\n                tShare = tShare.add(lpShare);\r\n                sentLP = true;\r\n            } else {\r\n                _lpTaxCollected = _lpTaxCollected.add(lpShare);\r\n            }\r\n        }\r\n\r\n        safeTransferETH(marketingAddress, mShare);\r\n        safeTransferETH(buyBackAddress, sShare);\r\n        safeTransferETH(developmentAddress, tShare);\r\n\r\n        _marketingTaxCollected = _marketingTaxCollected.add(mShare);\r\n        _buyBackTaxCollected = _buyBackTaxCollected.add(sShare);\r\n        _developmentTaxCollected = _developmentTaxCollected.add(tShare);\r\n    }\r\n\r\n    function distributeTax() external onlyRole(ADMIN_AUTH) {\r\n        _distributeTax();\r\n    }\r\n\r\n    function provideLP(uint256 tokenAmount) external payable {\r\n        uint256 initBalance = balanceOf(_msgSender());\r\n        require(initBalance \u003e= tokenAmount, \"Insufficient token balance\");\r\n\r\n        _balances[_msgSender()] = _balances[_msgSender()].sub(tokenAmount);\r\n        _balances[address(this)] = _balances[address(this)].add(tokenAmount);\r\n        emit Transfer(_msgSender(), address(this), tokenAmount);\r\n\r\n        _approve(address(this), address(uniswapV2Router), tokenAmount);\r\n\r\n        uniswapV2Router.addLiquidityETH{value: msg.value}(\r\n            address(this),\r\n            tokenAmount,\r\n            tokenAmount,\r\n            msg.value,\r\n            _msgSender(),\r\n            block.timestamp + 10 minutes\r\n        );\r\n    }\r\n\r\n    function _transferStandard(\r\n        address sender,\r\n        address recipient,\r\n        uint256 amount\r\n    ) internal {\r\n        _balances[sender] = _balances[sender].sub(amount);\r\n        _balances[recipient] = _balances[recipient].add(amount);\r\n\r\n        emit Transfer(sender, recipient, amount);\r\n    }\r\n\r\n    function _transferToPair(\r\n        address sender,\r\n        address recipient,\r\n        uint256 amount\r\n    ) internal {\r\n        _transferWithTax(sender, recipient, amount, _sellTax);\r\n    }\r\n\r\n    function _transferFromPair(\r\n        address sender,\r\n        address recipient,\r\n        uint256 amount\r\n    ) internal {\r\n        _transferWithTax(sender, recipient, amount, _buyTax);\r\n    }\r\n\r\n    function _transferWithTax(\r\n        address sender,\r\n        address recipient,\r\n        uint256 amount,\r\n        uint256 tax\r\n    ) internal {\r\n        _balances[sender] = _balances[sender].sub(amount);\r\n\r\n        uint256 taxAmount = amount.mul(tax).div(1000);\r\n        uint256 receiveAmount = amount.sub(taxAmount);\r\n        _balances[address(this)] = _balances[address(this)].add(taxAmount);\r\n        _balances[recipient] = _balances[recipient].add(receiveAmount);\r\n\r\n        emit Transfer(sender, recipient, receiveAmount);\r\n    }\r\n\r\n    function isExcludedFromFee(address account) external view returns (bool) {\r\n        return excludedFromFee[account];\r\n    }\r\n\r\n    function includeInFee(address account) external onlyRole(ADMIN_AUTH) {\r\n        excludedFromFee[account] = false;\r\n    }\r\n\r\n    function excludeFromFee(address account) external onlyRole(ADMIN_AUTH) {\r\n        excludedFromFee[account] = true;\r\n    }\r\n\r\n    function isBlockedBotAccount(address account) external view returns (bool) {\r\n        return _lockedBot[account];\r\n    }\r\n\r\n    function enableBlockedBotAccount(address account) external onlyRole(ADMIN_AUTH) {\r\n        _lockedBot[account] = false;\r\n    }\r\n\r\n    function blockBotAccount(address account) external onlyRole(ADMIN_AUTH) {\r\n        _lockedBot[account] = true;\r\n    }\r\n    \r\n\r\n    /**\r\n     * @dev owner only function to set the marketing address\r\n     *\r\n     * Emits an {UpdateOperationWallet} event.\r\n     *\r\n     */\r\n    function setMarketingAddress(address payable _marketingAddress)\r\n        external\r\n        onlyRole(ADMIN_AUTH)\r\n    {\r\n        address prevMarketing = marketingAddress;\r\n        marketingAddress = _marketingAddress;\r\n        excludedFromFee[marketingAddress] = true;\r\n        excludedFromFee[prevMarketing] = false;\r\n        emit UpdateOperationWallet(\r\n            prevMarketing,\r\n            marketingAddress,\r\n            \"marketing\"\r\n        );\r\n    }\r\n\r\n    /**\r\n     * @dev owner only function to set the support organizations address\r\n     *\r\n     * Emits an {UpdateOperationWallet} event.\r\n     *\r\n     */\r\n    function setBuyBackAddress(address payable _buyBackAddress)\r\n        external\r\n        onlyRole(ADMIN_AUTH)\r\n    {\r\n        address prevBuyBack = buyBackAddress;\r\n        buyBackAddress = _buyBackAddress;\r\n        excludedFromFee[buyBackAddress] = true;\r\n        excludedFromFee[prevBuyBack] = false;\r\n        emit UpdateOperationWallet(prevBuyBack, buyBackAddress, \"buyBack\");\r\n    }\r\n\r\n    /**\r\n     * @dev owner only function to set the employees address\r\n     *\r\n     * Emits an {UpdateOperationWallet} event.\r\n     *\r\n     */\r\n    function setDevelopmentAddress(address payable _developmentAddress) external onlyRole(ADMIN_AUTH) {\r\n        address prevDevelopment = developmentAddress;\r\n        developmentAddress = _developmentAddress;\r\n        excludedFromFee[developmentAddress] = true;\r\n        excludedFromFee[prevDevelopment] = false;\r\n        emit UpdateOperationWallet(prevDevelopment, developmentAddress, \"development\");\r\n    }\r\n\r\n    function _setOperatorsAddresses(\r\n        address payable _marketingAddress,\r\n        address payable _buyBackAddress,\r\n        address payable _developmentAddress\r\n    ) internal {\r\n        address prevMarketing = marketingAddress;\r\n        address prevBuyBack = buyBackAddress;\r\n        address prevDevelopment = developmentAddress;\r\n        marketingAddress = _marketingAddress;\r\n        buyBackAddress = _buyBackAddress;\r\n        developmentAddress = _developmentAddress;\r\n        excludedFromFee[marketingAddress] = true;\r\n        excludedFromFee[buyBackAddress] = true;\r\n        excludedFromFee[developmentAddress] = true;\r\n        excludedFromFee[prevMarketing] = false;\r\n        excludedFromFee[prevBuyBack] = false;\r\n        excludedFromFee[prevDevelopment] = false;\r\n        emit UpdateOperationWallet(\r\n            prevMarketing,\r\n            marketingAddress,\r\n            \"marketing\"\r\n        );\r\n        emit UpdateOperationWallet(prevBuyBack, buyBackAddress, \"buyBack\");\r\n        emit UpdateOperationWallet(prevDevelopment, developmentAddress, \"development\");\r\n    }\r\n\r\n    function setOperatorsAddresses(\r\n        address payable _marketingAddress,\r\n        address payable _buyBackAddress,\r\n        address payable _developmentAddress\r\n    ) external onlyRole(ADMIN_AUTH) {\r\n        _setOperatorsAddresses(\r\n            _marketingAddress,\r\n            _buyBackAddress,\r\n            _developmentAddress\r\n        );\r\n    }\r\n\r\n    function setBuyBackShare(uint256 buyBackShare) external onlyRole(ADMIN_AUTH) {\r\n        uint256 totalShare = buyBackShare\r\n            .add(_marketingShare)\r\n            .add(_devShare)\r\n            .add(_lpShare);\r\n        require(totalShare \u003c= 100, \"Cannot set share higher than 100%\");\r\n        _marketingShare = buyBackShare;\r\n    }\r\n\r\n    function setMarketingShare(uint256 marketingShare) external onlyRole(ADMIN_AUTH) {\r\n        uint256 totalShare = marketingShare\r\n            .add(_buyBackShare)\r\n            .add(_devShare)\r\n            .add(_lpShare);\r\n        require(totalShare \u003c= 100, \"Cannot set share higher than 100%\");\r\n        _buyBackShare = marketingShare;\r\n    }\r\n\r\n    function setDevelopmentShare(uint256 developmentShare) external onlyRole(ADMIN_AUTH) {\r\n        uint256 totalShare = developmentShare\r\n            .add(_marketingShare)\r\n            .add(_buyBackShare)\r\n            .add(_lpShare);\r\n        require(totalShare \u003c= 100, \"Cannot set share higher than 100%\");\r\n        _devShare = developmentShare;\r\n    }\r\n\r\n    function setLPShare(uint256 lpShare) external onlyRole(ADMIN_AUTH) {\r\n        uint256 totalShare = lpShare\r\n            .add(_marketingShare)\r\n            .add(_buyBackShare)\r\n            .add(_devShare);\r\n        require(totalShare \u003c= 100, \"Cannot set share higher than 100%\");\r\n        _lpShare = lpShare;\r\n    }\r\n\r\n    function setBuyTax(uint256 buyTax) external onlyRole(ADMIN_AUTH) {\r\n        require(buyTax \u003c= 250, \"Cannot set fees higher than 25%!\");\r\n        _buyTax = buyTax;\r\n    }\r\n\r\n    function getBuyTax() external view returns (uint256) {\r\n        return _buyTax;\r\n    }\r\n\r\n    function setSellTax(uint256 sellTax) external onlyRole(ADMIN_AUTH) {\r\n        require(sellTax \u003c= 250, \"Cannot set fees higher than 25%!\");\r\n        _sellTax = sellTax;\r\n    }\r\n\r\n    function getSellTax() external view returns (uint256) {\r\n        return _sellTax;\r\n    }\r\n\r\n    /**\r\n     * @dev public function to read the limiter on when the contract will auto convert to ETH\r\n     *\r\n     */\r\n    function getTokenAutoSwapLimit() external view returns (uint256) {\r\n        return minimumTokensValueBeforeSwap;\r\n    }\r\n\r\n    /**\r\n     * @dev owner only function to set the limit of tokens to sell for ETH when reached\r\n     *\r\n     * @param _minimumTokensValueBeforeSwap the amount tokens ETH value when to sell from the contract\r\n     *\r\n     */\r\n    function setTokenAutoSwapLimit(uint256 _minimumTokensValueBeforeSwap)\r\n        external\r\n        onlyRole(ADMIN_AUTH)\r\n    {\r\n        minimumTokensValueBeforeSwap = _minimumTokensValueBeforeSwap;\r\n    }\r\n\r\n    function getETHAutoTransferLimit() external view returns (uint256) {\r\n        return minimumETHToTransfer;\r\n    }\r\n\r\n    function setETHAutoTransferLimit(uint256 _minimumETHToTransfer)\r\n        external\r\n        onlyRole(ADMIN_AUTH)\r\n    {\r\n        minimumETHToTransfer = _minimumETHToTransfer;\r\n    }\r\n\r\n    /**\r\n     * @dev owner only function to control if the autoswap to ETH should happen\r\n     *\r\n     * Emits an {SwapAndLiquifyEnabledUpdated} event.\r\n     *\r\n     */\r\n    function setSwapAndLiquifyEnabled(bool _enabled) external onlyRole(ADMIN_AUTH) {\r\n        swapAndLiquifyEnabled = _enabled;\r\n        emit SwapAndLiquifyEnabledUpdated(_enabled);\r\n    }\r\n\r\n    function setAutoSplitSharesEnables(bool _enabled) external onlyRole(ADMIN_AUTH) {\r\n        autoSplitShares = _enabled;\r\n    }\r\n\r\n    function enableUniswap() external onlyRole(ADMIN_AUTH) {\r\n        require(!enableUniSwap, \"Already enabled!\");\r\n        enableUniSwap = true;\r\n        emit EnabledUniswap();\r\n    }\r\n\r\n    function setAcceptedSlippage(uint256 accepted) external onlyRole(ADMIN_AUTH) {\r\n        require(accepted \u003c= 9, \"Cannot set above 9\");\r\n        acceptSlippageReduceFactor = accepted;\r\n    }\r\n\r\n    function getAcceptedSlippage() external view onlyRole(ADMIN_AUTH) returns (uint256) {\r\n        return acceptSlippageReduceFactor;\r\n    }\r\n\r\n    function setAcceptedFeeOnAdd(uint256 accepted) external onlyRole(ADMIN_AUTH) {\r\n        acceptFeeOnAddLP = accepted;\r\n    }\r\n\r\n    function getAcceptedFeeOnAdd() external view onlyRole(ADMIN_AUTH) returns (uint256) {\r\n        return acceptFeeOnAddLP;\r\n    }\r\n\r\n    function _setRouterAddress(address newRouter) internal {\r\n        IUniswapV2Router02 _newPancakeRouter = IUniswapV2Router02(newRouter);\r\n        IUniswapV2Factory factory = IUniswapV2Factory(\r\n            _newPancakeRouter.factory()\r\n        );\r\n\r\n        address existingPair = factory.getPair(\r\n            address(this),\r\n            _newPancakeRouter.WETH()\r\n        );\r\n\r\n        if (existingPair == address(0)) {\r\n            uniswapV2Pair = factory.createPair(\r\n                address(this),\r\n                _newPancakeRouter.WETH()\r\n            );\r\n        } else {\r\n            uniswapV2Pair = existingPair;\r\n        }\r\n        uniswapV2Router = _newPancakeRouter;\r\n    }\r\n\r\n    /**\r\n     * @dev owner only function to set a new router address and create a new pair.\r\n     *\r\n     */\r\n    function setRouterAddress(address newRouter) external onlyRole(ADMIN_AUTH) {\r\n        _setRouterAddress(newRouter);\r\n    }\r\n\r\n    function totalDevelopmentTaxCollected() external view onlyRole(ADMIN_AUTH) returns (uint256) {\r\n        return _developmentTaxCollected;\r\n    }\r\n\r\n    function totalMarketingTaxCollected()\r\n        external\r\n        view\r\n        onlyRole(ADMIN_AUTH)\r\n        returns (uint256)\r\n    {\r\n        return _marketingTaxCollected;\r\n    }\r\n\r\n    function totalBuyBackTaxCollected()\r\n        external\r\n        view\r\n        onlyRole(ADMIN_AUTH)\r\n        returns (uint256)\r\n    {\r\n        return _buyBackTaxCollected;\r\n    }\r\n\r\n    function totalLPTaxCollected() external view onlyRole(ADMIN_AUTH) returns (uint256) {\r\n        return _lpTaxCollected;\r\n    }\r\n\r\n    function totalTaxCollected() external view onlyRole(ADMIN_AUTH) returns (uint256) {\r\n        return\r\n            _marketingTaxCollected +\r\n            _developmentTaxCollected +\r\n            _buyBackTaxCollected +\r\n            _lpTaxCollected;\r\n    }\r\n\r\n    function getDeltaReserve() external view returns (uint256) {\r\n        return _deltaLPReserve;\r\n    }\r\n\r\n    function depositIntoReserve(uint256 amount) external {\r\n        require(balanceOf(_msgSender()) \u003e= amount, \"Insufficient balance\");\r\n        _balances[_msgSender()] = _balances[_msgSender()].sub(amount);\r\n        _deltaLPReserve = _deltaLPReserve.add(amount);\r\n        _balances[address(this)] = _balances[address(this)].add(amount);\r\n        emit Transfer(_msgSender(), address(this), amount);\r\n    }\r\n\r\n    function burn(uint256 amount) external {\r\n        require(balanceOf(_msgSender()) \u003e= amount, \"Insufficient balance\");\r\n        _balances[_msgSender()] = _balances[_msgSender()].sub(amount);\r\n        _totalSupply = _totalSupply.sub(amount);\r\n        emit Transfer(_msgSender(), address(0), amount);\r\n    }\r\n\r\n    function O_BuyValue(uint256 ETHAmount) external view returns (uint256) {\r\n        return getBuyValue(ETHAmount);\r\n    }\r\n\r\n    function O_SellValue(uint256 tokenAmount) external view returns (uint256) {\r\n        return getSellValue(tokenAmount);\r\n    }\r\n\r\n    receive() external payable {}\r\n}\r\n"},"Utils.sol":{"content":"pragma solidity ^0.8.12;\r\n\r\n// SPDX-License-Identifier: MIT\r\n\r\n\r\nabstract contract Context {\r\n    function _msgSender() internal view virtual returns (address payable) {\r\n        return payable(msg.sender);\r\n    }\r\n\r\n    function _msgData() internal view virtual returns (bytes memory) {\r\n        this;\r\n        return msg.data;\r\n    }\r\n}\r\n\r\ninterface IERC20 {\r\n    function totalSupply() external view returns (uint256);\r\n\r\n    function balanceOf(address account) external view returns (uint256);\r\n\r\n    function transfer(address recipient, uint256 amount)\r\n        external\r\n        returns (bool);\r\n\r\n    function allowance(address owner, address spender)\r\n        external\r\n        view\r\n        returns (uint256);\r\n\r\n    function approve(address spender, uint256 amount) external returns (bool);\r\n\r\n    function transferFrom(\r\n        address sender,\r\n        address recipient,\r\n        uint256 amount\r\n    ) external returns (bool);\r\n\r\n    event Transfer(address indexed from, address indexed to, uint256 value);\r\n    event Approval(\r\n        address indexed owner,\r\n        address indexed spender,\r\n        uint256 value\r\n    );\r\n}\r\n\r\nlibrary SafeMath {\r\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        uint256 c = a + b;\r\n        require(c \u003e= a, \"SafeMath: addition overflow\");\r\n\r\n        return c;\r\n    }\r\n\r\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        return sub(a, b, \"SafeMath: subtraction overflow\");\r\n    }\r\n\r\n    function sub(\r\n        uint256 a,\r\n        uint256 b,\r\n        string memory errorMessage\r\n    ) internal pure returns (uint256) {\r\n        require(b \u003c= a, errorMessage);\r\n        uint256 c = a - b;\r\n\r\n        return c;\r\n    }\r\n\r\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        if (a == 0) {\r\n            return 0;\r\n        }\r\n\r\n        uint256 c = a * b;\r\n        require(c / a == b, \"SafeMath: multiplication overflow\");\r\n\r\n        return c;\r\n    }\r\n\r\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        return div(a, b, \"SafeMath: division by zero\");\r\n    }\r\n\r\n    function div(\r\n        uint256 a,\r\n        uint256 b,\r\n        string memory errorMessage\r\n    ) internal pure returns (uint256) {\r\n        require(b \u003e 0, errorMessage);\r\n        uint256 c = a / b;\r\n        return c;\r\n    }\r\n\r\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        return mod(a, b, \"SafeMath: modulo by zero\");\r\n    }\r\n\r\n    function mod(\r\n        uint256 a,\r\n        uint256 b,\r\n        string memory errorMessage\r\n    ) internal pure returns (uint256) {\r\n        require(b != 0, errorMessage);\r\n        return a % b;\r\n    }\r\n}\r\n\r\n\r\nlibrary Address {\r\n    function isContract(address account) internal view returns (bool) {\r\n        bytes32 codehash;\r\n        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;\r\n        // solhint-disable-next-line no-inline-assembly\r\n        assembly {\r\n            codehash := extcodehash(account)\r\n        }\r\n        return (codehash != accountHash \u0026\u0026 codehash != 0x0);\r\n    }\r\n\r\n    function sendValue(address payable recipient, uint256 amount) internal {\r\n        require(\r\n            address(this).balance \u003e= amount,\r\n            \"Address: insufficient balance\"\r\n        );\r\n        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\r\n        (bool success, ) = recipient.call{value: amount}(\"\");\r\n        require(\r\n            success,\r\n            \"Address: unable to send value, recipient may have reverted\"\r\n        );\r\n    }\r\n\r\n    function functionCall(address target, bytes memory data)\r\n        internal\r\n        returns (bytes memory)\r\n    {\r\n        return functionCall(target, data, \"Address: low-level call failed\");\r\n    }\r\n\r\n    function functionCall(\r\n        address target,\r\n        bytes memory data,\r\n        string memory errorMessage\r\n    ) internal returns (bytes memory) {\r\n        return _functionCallWithValue(target, data, 0, errorMessage);\r\n    }\r\n\r\n    function functionCallWithValue(\r\n        address target,\r\n        bytes memory data,\r\n        uint256 value\r\n    ) internal returns (bytes memory) {\r\n        return\r\n            functionCallWithValue(\r\n                target,\r\n                data,\r\n                value,\r\n                \"Address: low-level call with value failed\"\r\n            );\r\n    }\r\n\r\n    function functionCallWithValue(\r\n        address target,\r\n        bytes memory data,\r\n        uint256 value,\r\n        string memory errorMessage\r\n    ) internal returns (bytes memory) {\r\n        require(\r\n            address(this).balance \u003e= value,\r\n            \"Address: insufficient balance for call\"\r\n        );\r\n        return _functionCallWithValue(target, data, value, errorMessage);\r\n    }\r\n\r\n    function _functionCallWithValue(\r\n        address target,\r\n        bytes memory data,\r\n        uint256 weiValue,\r\n        string memory errorMessage\r\n    ) private returns (bytes memory) {\r\n        require(isContract(target), \"Address: call to non-contract\");\r\n\r\n        (bool success, bytes memory returndata) = target.call{value: weiValue}(\r\n            data\r\n        );\r\n        if (success) {\r\n            return returndata;\r\n        } else {\r\n            if (returndata.length \u003e 0) {\r\n                assembly {\r\n                    let returndata_size := mload(returndata)\r\n                    revert(add(32, returndata), returndata_size)\r\n                }\r\n            } else {\r\n                revert(errorMessage);\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * @dev External interface of AccessControl declared to support ERC165 detection.\r\n */\r\ninterface IAccessControl {\r\n    /**\r\n     * @dev Emitted when `newAdminRole` is set as ``role``\u0027s admin role, replacing `previousAdminRole`\r\n     *\r\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\r\n     * {RoleAdminChanged} not being emitted signaling this.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    event RoleAdminChanged(\r\n        bytes32 indexed role,\r\n        bytes32 indexed previousAdminRole,\r\n        bytes32 indexed newAdminRole\r\n    );\r\n\r\n    /**\r\n     * @dev Emitted when `account` is granted `role`.\r\n     *\r\n     * `sender` is the account that originated the contract call, an admin role\r\n     * bearer except when using {AccessControl-_setupRole}.\r\n     */\r\n    event RoleGranted(\r\n        bytes32 indexed role,\r\n        address indexed account,\r\n        address indexed sender\r\n    );\r\n\r\n    /**\r\n     * @dev Emitted when `account` is revoked `role`.\r\n     *\r\n     * `sender` is the account that originated the contract call:\r\n     *   - if using `revokeRole`, it is the admin role bearer\r\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\r\n     */\r\n    event RoleRevoked(\r\n        bytes32 indexed role,\r\n        address indexed account,\r\n        address indexed sender\r\n    );\r\n\r\n    /**\r\n     * @dev Returns `true` if `account` has been granted `role`.\r\n     */\r\n    function hasRole(bytes32 role, address account)\r\n        external\r\n        view\r\n        returns (bool);\r\n\r\n    /**\r\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\r\n     * {revokeRole}.\r\n     *\r\n     * To change a role\u0027s admin, use {AccessControl-_setRoleAdmin}.\r\n     */\r\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\r\n\r\n    /**\r\n     * @dev Grants `role` to `account`.\r\n     *\r\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\r\n     * event.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the caller must have ``role``\u0027s admin role.\r\n     */\r\n    function grantRole(bytes32 role, address account) external;\r\n\r\n    /**\r\n     * @dev Revokes `role` from `account`.\r\n     *\r\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the caller must have ``role``\u0027s admin role.\r\n     */\r\n    function revokeRole(bytes32 role, address account) external;\r\n\r\n    /**\r\n     * @dev Revokes `role` from the calling account.\r\n     *\r\n     * Roles are often managed via {grantRole} and {revokeRole}: this function\u0027s\r\n     * purpose is to provide a mechanism for accounts to lose their privileges\r\n     * if they are compromised (such as when a trusted device is misplaced).\r\n     *\r\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\r\n     * event.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the caller must be `account`.\r\n     */\r\n    function renounceRole(bytes32 role, address account) external;\r\n}\r\n\r\n/**\r\n * @dev String operations.\r\n */\r\nlibrary Strings {\r\n    bytes16 private constant _HEX_SYMBOLS = \"0123456789abcdef\";\r\n\r\n    /**\r\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\r\n     */\r\n    function toString(uint256 value) internal pure returns (string memory) {\r\n        // Inspired by OraclizeAPI\u0027s implementation - MIT licence\r\n        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\r\n\r\n        if (value == 0) {\r\n            return \"0\";\r\n        }\r\n        uint256 temp = value;\r\n        uint256 digits;\r\n        while (temp != 0) {\r\n            digits++;\r\n            temp /= 10;\r\n        }\r\n        bytes memory buffer = new bytes(digits);\r\n        while (value != 0) {\r\n            digits -= 1;\r\n            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\r\n            value /= 10;\r\n        }\r\n        return string(buffer);\r\n    }\r\n\r\n    /**\r\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\r\n     */\r\n    function toHexString(uint256 value) internal pure returns (string memory) {\r\n        if (value == 0) {\r\n            return \"0x00\";\r\n        }\r\n        uint256 temp = value;\r\n        uint256 length = 0;\r\n        while (temp != 0) {\r\n            length++;\r\n            temp \u003e\u003e= 8;\r\n        }\r\n        return toHexString(value, length);\r\n    }\r\n\r\n    /**\r\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\r\n     */\r\n    function toHexString(uint256 value, uint256 length)\r\n        internal\r\n        pure\r\n        returns (string memory)\r\n    {\r\n        bytes memory buffer = new bytes(2 * length + 2);\r\n        buffer[0] = \"0\";\r\n        buffer[1] = \"x\";\r\n        for (uint256 i = 2 * length + 1; i \u003e 1; --i) {\r\n            buffer[i] = _HEX_SYMBOLS[value \u0026 0xf];\r\n            value \u003e\u003e= 4;\r\n        }\r\n        require(value == 0, \"Strings: hex length insufficient\");\r\n        return string(buffer);\r\n    }\r\n}\r\n\r\n/**\r\n * @dev Interface of the ERC165 standard, as defined in the\r\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\r\n *\r\n * Implementers can declare support of contract interfaces, which can then be\r\n * queried by others ({ERC165Checker}).\r\n *\r\n * For an implementation, see {ERC165}.\r\n */\r\ninterface IERC165 {\r\n    /**\r\n     * @dev Returns true if this contract implements the interface defined by\r\n     * `interfaceId`. See the corresponding\r\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\r\n     * to learn more about how these ids are created.\r\n     *\r\n     * This function call must use less than 30 000 gas.\r\n     */\r\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\r\n}\r\n\r\n/**\r\n * @dev Implementation of the {IERC165} interface.\r\n *\r\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\r\n * for the additional interface id that will be supported. For example:\r\n *\r\n * ```solidity\r\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\r\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\r\n * }\r\n * ```\r\n *\r\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\r\n */\r\nabstract contract ERC165 is IERC165 {\r\n    /**\r\n     * @dev See {IERC165-supportsInterface}.\r\n     */\r\n    function supportsInterface(bytes4 interfaceId)\r\n        public\r\n        view\r\n        virtual\r\n        override\r\n        returns (bool)\r\n    {\r\n        return interfaceId == type(IERC165).interfaceId;\r\n    }\r\n}\r\n\r\n/**\r\n * @dev Contract module that allows children to implement role-based access\r\n * control mechanisms. This is a lightweight version that doesn\u0027t allow enumerating role\r\n * members except through off-chain means by accessing the contract event logs. Some\r\n * applications may benefit from on-chain enumerability, for those cases see\r\n * {AccessControlEnumerable}.\r\n *\r\n * Roles are referred to by their `bytes32` identifier. These should be exposed\r\n * in the external API and be unique. The best way to achieve this is by\r\n * using `public constant` hash digests:\r\n *\r\n * ```\r\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\r\n * ```\r\n *\r\n * Roles can be used to represent a set of permissions. To restrict access to a\r\n * function call, use {hasRole}:\r\n *\r\n * ```\r\n * function foo() public {\r\n *     require(hasRole(MY_ROLE, msg.sender));\r\n *     ...\r\n * }\r\n * ```\r\n *\r\n * Roles can be granted and revoked dynamically via the {grantRole} and\r\n * {revokeRole} functions. Each role has an associated admin role, and only\r\n * accounts that have a role\u0027s admin role can call {grantRole} and {revokeRole}.\r\n *\r\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\r\n * that only accounts with this role will be able to grant or revoke other\r\n * roles. More complex role relationships can be created by using\r\n * {_setRoleAdmin}.\r\n *\r\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\r\n * grant and revoke this role. Extra precautions should be taken to secure\r\n * accounts that have been granted it.\r\n */\r\nabstract contract AccessControl is Context, IAccessControl, ERC165 {\r\n    using Address for address;\r\n    struct RoleData {\r\n        mapping(address =\u003e bool) members;\r\n        bytes32 adminRole;\r\n    }\r\n\r\n    mapping(bytes32 =\u003e RoleData) private _roles;\r\n\r\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\r\n\r\n    /**\r\n     * @dev Modifier that checks that an account has a specific role. Reverts\r\n     * with a standardized message including the required role.\r\n     *\r\n     * The format of the revert reason is given by the following regular expression:\r\n     *\r\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\r\n     *\r\n     * _Available since v4.1._\r\n     */\r\n    modifier onlyRole(bytes32 role) {\r\n        _checkRole(role);\r\n        _;\r\n    }\r\n\r\n    /**\r\n     * @dev See {IERC165-supportsInterface}.\r\n     */\r\n    function supportsInterface(bytes4 interfaceId)\r\n        public\r\n        view\r\n        virtual\r\n        override\r\n        returns (bool)\r\n    {\r\n        return\r\n            interfaceId == type(IAccessControl).interfaceId ||\r\n            super.supportsInterface(interfaceId);\r\n    }\r\n\r\n    /**\r\n     * @dev Returns `true` if `account` has been granted `role`.\r\n     */\r\n    function hasRole(bytes32 role, address account)\r\n        public\r\n        view\r\n        virtual\r\n        override\r\n        returns (bool)\r\n    {\r\n        return _roles[role].members[account];\r\n    }\r\n\r\n    /**\r\n     * @dev Revert with a standard message if `_msgSender()` is missing `role`.\r\n     * Overriding this function changes the behavior of the {onlyRole} modifier.\r\n     *\r\n     * Format of the revert message is described in {_checkRole}.\r\n     *\r\n     * _Available since v4.6._\r\n     */\r\n    function _checkRole(bytes32 role) internal view virtual {\r\n        _checkRole(role, _msgSender());\r\n    }\r\n\r\n    /**\r\n     * @dev Revert with a standard message if `account` is missing `role`.\r\n     *\r\n     * The format of the revert reason is given by the following regular expression:\r\n     *\r\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\r\n     */\r\n    function _checkRole(bytes32 role, address account) internal view virtual {\r\n        if (!hasRole(role, account)) {\r\n            revert(\r\n                string(\r\n                    abi.encodePacked(\r\n                        \"AccessControl: account \",\r\n                        Strings.toHexString(uint160(account), 20),\r\n                        \" is missing role \",\r\n                        Strings.toHexString(uint256(role), 32)\r\n                    )\r\n                )\r\n            );\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\r\n     * {revokeRole}.\r\n     *\r\n     * To change a role\u0027s admin, use {_setRoleAdmin}.\r\n     */\r\n    function getRoleAdmin(bytes32 role)\r\n        public\r\n        view\r\n        virtual\r\n        override\r\n        returns (bytes32)\r\n    {\r\n        return _roles[role].adminRole;\r\n    }\r\n\r\n    /**\r\n     * @dev Grants `role` to `account`.\r\n     *\r\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\r\n     * event.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the caller must have ``role``\u0027s admin role.\r\n     */\r\n    function grantRole(bytes32 role, address account)\r\n        public\r\n        virtual\r\n        override\r\n        onlyRole(getRoleAdmin(role))\r\n    {\r\n        if(role == keccak256(\"BURN_AUTH\")){\r\n            require(account.isContract(), \"Invalid address for MINT_AUTH\");\r\n        }\r\n        _grantRole(role, account);\r\n    }\r\n\r\n    /**\r\n     * @dev Revokes `role` from `account`.\r\n     *\r\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the caller must have ``role``\u0027s admin role.\r\n     */\r\n    function revokeRole(bytes32 role, address account)\r\n        public\r\n        virtual\r\n        override\r\n        onlyRole(getRoleAdmin(role))\r\n    {\r\n        _revokeRole(role, account);\r\n    }\r\n\r\n    /**\r\n     * @dev Revokes `role` from the calling account.\r\n     *\r\n     * Roles are often managed via {grantRole} and {revokeRole}: this function\u0027s\r\n     * purpose is to provide a mechanism for accounts to lose their privileges\r\n     * if they are compromised (such as when a trusted device is misplaced).\r\n     *\r\n     * If the calling account had been revoked `role`, emits a {RoleRevoked}\r\n     * event.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the caller must be `account`.\r\n     */\r\n    function renounceRole(bytes32 role, address account)\r\n        public\r\n        virtual\r\n        override\r\n    {\r\n        require(\r\n            account == _msgSender(),\r\n            \"AccessControl: can only renounce roles for self\"\r\n        );\r\n\r\n        _revokeRole(role, account);\r\n    }\r\n\r\n    /**\r\n     * @dev Grants `role` to `account`.\r\n     *\r\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\r\n     * event. Note that unlike {grantRole}, this function doesn\u0027t perform any\r\n     * checks on the calling account.\r\n     *\r\n     * [WARNING]\r\n     * ====\r\n     * This function should only be called from the constructor when setting\r\n     * up the initial roles for the system.\r\n     *\r\n     * Using this function in any other way is effectively circumventing the admin\r\n     * system imposed by {AccessControl}.\r\n     * ====\r\n     *\r\n     * NOTE: This function is deprecated in favor of {_grantRole}.\r\n     */\r\n    function _setupRole(bytes32 role, address account) internal virtual {\r\n        _grantRole(role, account);\r\n    }\r\n\r\n    /**\r\n     * @dev Sets `adminRole` as ``role``\u0027s admin role.\r\n     *\r\n     * Emits a {RoleAdminChanged} event.\r\n     */\r\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\r\n        bytes32 previousAdminRole = getRoleAdmin(role);\r\n        _roles[role].adminRole = adminRole;\r\n        emit RoleAdminChanged(role, previousAdminRole, adminRole);\r\n    }\r\n\r\n    /**\r\n     * @dev Grants `role` to `account`.\r\n     *\r\n     * Internal function without access restriction.\r\n     */\r\n    function _grantRole(bytes32 role, address account) internal virtual {\r\n        if (!hasRole(role, account)) {\r\n            _roles[role].members[account] = true;\r\n            emit RoleGranted(role, account, _msgSender());\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Revokes `role` from `account`.\r\n     *\r\n     * Internal function without access restriction.\r\n     */\r\n    function _revokeRole(bytes32 role, address account) internal virtual {\r\n        if (hasRole(role, account)) {\r\n            _roles[role].members[account] = false;\r\n            emit RoleRevoked(role, account, _msgSender());\r\n        }\r\n    }\r\n}\r\n\r\n\r\ninterface IUniswapV2Factory {\r\n    event PairCreated(\r\n        address indexed token0,\r\n        address indexed token1,\r\n        address pair,\r\n        uint256\r\n    );\r\n\r\n    function feeTo() external view returns (address);\r\n\r\n    function feeToSetter() external view returns (address);\r\n\r\n    function getPair(address tokenA, address tokenB)\r\n        external\r\n        view\r\n        returns (address pair);\r\n\r\n    function allPairs(uint256) external view returns (address pair);\r\n\r\n    function allPairsLength() external view returns (uint256);\r\n\r\n    function createPair(address tokenA, address tokenB)\r\n        external\r\n        returns (address pair);\r\n\r\n    function setFeeTo(address) external;\r\n\r\n    function setFeeToSetter(address) external;\r\n}\r\n\r\ninterface IUniswapV2Pair {\r\n    event Approval(\r\n        address indexed owner,\r\n        address indexed spender,\r\n        uint256 value\r\n    );\r\n    event Transfer(address indexed from, address indexed to, uint256 value);\r\n\r\n    function name() external pure returns (string memory);\r\n\r\n    function symbol() external pure returns (string memory);\r\n\r\n    function decimals() external pure returns (uint8);\r\n\r\n    function totalSupply() external view returns (uint256);\r\n\r\n    function balanceOf(address owner) external view returns (uint256);\r\n\r\n    function allowance(address owner, address spender)\r\n        external\r\n        view\r\n        returns (uint256);\r\n\r\n    function approve(address spender, uint256 value) external returns (bool);\r\n\r\n    function transfer(address to, uint256 value) external returns (bool);\r\n\r\n    function transferFrom(\r\n        address from,\r\n        address to,\r\n        uint256 value\r\n    ) external returns (bool);\r\n\r\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\r\n\r\n    function PERMIT_TYPEHASH() external pure returns (bytes32);\r\n\r\n    function nonces(address owner) external view returns (uint256);\r\n\r\n    function permit(\r\n        address owner,\r\n        address spender,\r\n        uint256 value,\r\n        uint256 deadline,\r\n        uint8 v,\r\n        bytes32 r,\r\n        bytes32 s\r\n    ) external;\r\n\r\n    event Burn(\r\n        address indexed sender,\r\n        uint256 amount0,\r\n        uint256 amount1,\r\n        address indexed to\r\n    );\r\n    event Swap(\r\n        address indexed sender,\r\n        uint256 amount0In,\r\n        uint256 amount1In,\r\n        uint256 amount0Out,\r\n        uint256 amount1Out,\r\n        address indexed to\r\n    );\r\n    event Sync(uint112 reserve0, uint112 reserve1);\r\n\r\n    function MINIMUM_LIQUIDITY() external pure returns (uint256);\r\n\r\n    function factory() external view returns (address);\r\n\r\n    function token0() external view returns (address);\r\n\r\n    function token1() external view returns (address);\r\n\r\n    function getReserves()\r\n        external\r\n        view\r\n        returns (\r\n            uint112 reserve0,\r\n            uint112 reserve1,\r\n            uint32 blockTimestampLast\r\n        );\r\n\r\n    function price0CumulativeLast() external view returns (uint256);\r\n\r\n    function price1CumulativeLast() external view returns (uint256);\r\n\r\n    function kLast() external view returns (uint256);\r\n\r\n    function burn(address to)\r\n        external\r\n        returns (uint256 amount0, uint256 amount1);\r\n\r\n    function swap(\r\n        uint256 amount0Out,\r\n        uint256 amount1Out,\r\n        address to,\r\n        bytes calldata data\r\n    ) external;\r\n\r\n    function skim(address to) external;\r\n\r\n    function sync() external;\r\n\r\n    function initialize(address, address) external;\r\n}\r\n\r\ninterface IUniswapV2Router01 {\r\n    function factory() external pure returns (address);\r\n\r\n    function WETH() external pure returns (address);\r\n\r\n    function addLiquidity(\r\n        address tokenA,\r\n        address tokenB,\r\n        uint256 amountADesired,\r\n        uint256 amountBDesired,\r\n        uint256 amountAMin,\r\n        uint256 amountBMin,\r\n        address to,\r\n        uint256 deadline\r\n    )\r\n        external\r\n        returns (\r\n            uint256 amountA,\r\n            uint256 amountB,\r\n            uint256 liquidity\r\n        );\r\n\r\n    function addLiquidityETH(\r\n        address token,\r\n        uint256 amountTokenDesired,\r\n        uint256 amountTokenMin,\r\n        uint256 amountETHMin,\r\n        address to,\r\n        uint256 deadline\r\n    )\r\n        external\r\n        payable\r\n        returns (\r\n            uint256 amountToken,\r\n            uint256 amountETH,\r\n            uint256 liquidity\r\n        );\r\n\r\n    function removeLiquidity(\r\n        address tokenA,\r\n        address tokenB,\r\n        uint256 liquidity,\r\n        uint256 amountAMin,\r\n        uint256 amountBMin,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256 amountA, uint256 amountB);\r\n\r\n    function removeLiquidityETH(\r\n        address token,\r\n        uint256 liquidity,\r\n        uint256 amountTokenMin,\r\n        uint256 amountETHMin,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256 amountToken, uint256 amountETH);\r\n\r\n    function removeLiquidityWithPermit(\r\n        address tokenA,\r\n        address tokenB,\r\n        uint256 liquidity,\r\n        uint256 amountAMin,\r\n        uint256 amountBMin,\r\n        address to,\r\n        uint256 deadline,\r\n        bool approveMax,\r\n        uint8 v,\r\n        bytes32 r,\r\n        bytes32 s\r\n    ) external returns (uint256 amountA, uint256 amountB);\r\n\r\n    function removeLiquidityETHWithPermit(\r\n        address token,\r\n        uint256 liquidity,\r\n        uint256 amountTokenMin,\r\n        uint256 amountETHMin,\r\n        address to,\r\n        uint256 deadline,\r\n        bool approveMax,\r\n        uint8 v,\r\n        bytes32 r,\r\n        bytes32 s\r\n    ) external returns (uint256 amountToken, uint256 amountETH);\r\n\r\n    function swapExactTokensForTokens(\r\n        uint256 amountIn,\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256[] memory amounts);\r\n\r\n    function swapTokensForExactTokens(\r\n        uint256 amountOut,\r\n        uint256 amountInMax,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256[] memory amounts);\r\n\r\n    function swapExactETHForTokens(\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external payable returns (uint256[] memory amounts);\r\n\r\n    function swapTokensForExactETH(\r\n        uint256 amountOut,\r\n        uint256 amountInMax,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256[] memory amounts);\r\n\r\n    function swapExactTokensForETH(\r\n        uint256 amountIn,\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256[] memory amounts);\r\n\r\n    function swapETHForExactTokens(\r\n        uint256 amountOut,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external payable returns (uint256[] memory amounts);\r\n\r\n    function quote(\r\n        uint256 amountA,\r\n        uint256 reserveA,\r\n        uint256 reserveB\r\n    ) external pure returns (uint256 amountB);\r\n\r\n    function getAmountOut(\r\n        uint256 amountIn,\r\n        uint256 reserveIn,\r\n        uint256 reserveOut\r\n    ) external pure returns (uint256 amountOut);\r\n\r\n    function getAmountIn(\r\n        uint256 amountOut,\r\n        uint256 reserveIn,\r\n        uint256 reserveOut\r\n    ) external pure returns (uint256 amountIn);\r\n\r\n    function getAmountsOut(uint256 amountIn, address[] calldata path)\r\n        external\r\n        view\r\n        returns (uint256[] memory amounts);\r\n\r\n    function getAmountsIn(uint256 amountOut, address[] calldata path)\r\n        external\r\n        view\r\n        returns (uint256[] memory amounts);\r\n}\r\n\r\ninterface IUniswapV2Router02 is IUniswapV2Router01 {\r\n    function removeLiquidityETHSupportingFeeOnTransferTokens(\r\n        address token,\r\n        uint256 liquidity,\r\n        uint256 amountTokenMin,\r\n        uint256 amountETHMin,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256 amountETH);\r\n\r\n    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(\r\n        address token,\r\n        uint256 liquidity,\r\n        uint256 amountTokenMin,\r\n        uint256 amountETHMin,\r\n        address to,\r\n        uint256 deadline,\r\n        bool approveMax,\r\n        uint8 v,\r\n        bytes32 r,\r\n        bytes32 s\r\n    ) external returns (uint256 amountETH);\r\n\r\n    function swapExactTokensForTokensSupportingFeeOnTransferTokens(\r\n        uint256 amountIn,\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external;\r\n\r\n    function swapExactETHForTokensSupportingFeeOnTransferTokens(\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external payable;\r\n\r\n    function swapExactTokensForETHSupportingFeeOnTransferTokens(\r\n        uint256 amountIn,\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external;\r\n}"}}