Contract 0xA749D99d58b1fC462880A1AeAB9b341e10fFd981

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;

import "./libraries/SafeERC20.sol";
import "./libraries/Math.sol";

import "./helpers/Ownable.sol";

import "./helpers/Pausable.sol";

import "./libraries/UniversalERC20.sol";

import "./helpers/ReentrancyGuard.sol";

import "./helpers/Whitelist.sol";

import "./interfaces/IPancakeRouter02.sol";
import "./interfaces/IPancakePair.sol";
import "./interfaces/IWETH.sol";
import "./interfaces/ICurvePool.sol";

contract AutoSwap_02 is Ownable, ReentrancyGuard, Pausable, Whitelist {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    using UniversalERC20 for IERC20;
    using UniversalERC20 for IPancakePair;

    uint256 public feeRate;
    uint256 public referrerFeeRate;
    address payable public constant WETH = 0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7;

    event FeeRateChanged(
        uint256 indexed oldFeeRate,
        uint256 indexed newFeeRate
    );
    event ReferrerFeeRateChanged(
        uint256 indexed oldReferrerFeeRate,
        uint256 indexed newReferrerFeeRate
    );

    event Order(
        address indexed sender,
        IERC20 indexed inToken,
        IERC20 indexed outToken,
        uint256 inAmount,
        uint256 outAmount
    );

    event Swapped(
        IERC20 indexed inToken,
        IERC20 indexed outToken,
        address indexed referrer,
        uint256 inAmount,
        uint256 outAmount,
        uint256 fee,
        uint256 referrerFee,
        bool isLPSwap
    );

    struct CallStruct {
        address target;
        IERC20 inToken;
        uint256 amount;
        bytes4 selector;
        bytes data;
        bytes prefix;
    }
    struct AddLiquidityCallStruct {
        IPancakeRouter02 router;
        uint amount0Min;
        uint amount1Min;
        uint deadline;
    }

    enum RouterTypes { Uniswap, Curve }

    struct QuoteCallStruct {
      address router;
      RouterTypes routerType;
      uint amount;
      address[] path;
      uint inputTokenIndex;
      uint outputTokenIndex;
      int128 i;
      int128 j;
    }

    constructor(
        address _owner,
        uint256 _feeRate,
        uint256 _referrerFeeRate
    ) public {
        transferOwnership(_owner);
        feeRate = _feeRate;
        referrerFeeRate = _referrerFeeRate;
    }

    function _getAmountsOut(
        uint tokensLookupSize,
        uint inputAmount,
        QuoteCallStruct[] calldata calls
    ) internal view returns (uint[] memory amountsOut) {
        uint[] memory balance = new uint[](tokensLookupSize);
        balance[0] = inputAmount;

        for (uint256 i = 0; i < calls.length; i++) {
            require(isMember(calls[i].router), "!whitelisted");
            uint subswapInAmount = Math.min(
                calls[i].amount,
                balance[calls[i].inputTokenIndex]
            );
            balance[calls[i].inputTokenIndex] -= subswapInAmount;
            if (calls[i].routerType == RouterTypes.Uniswap) {
                uint[] memory amountsOut = IPancakeRouter02(calls[i].router).getAmountsOut(
                    subswapInAmount,
                    calls[i].path
                );
                balance[calls[i].outputTokenIndex] += amountsOut[amountsOut.length - 1];
            } else {
                uint amountOut = ICurvePool(calls[i].router).get_dy(
                    calls[i].i,
                    calls[i].j,
                    subswapInAmount
                );
                balance[calls[i].outputTokenIndex] += amountOut;
            }
        }
        return balance;
    }
    function getAmountsOut(
        uint tokensLookupSize,
        uint inputAmount,
        QuoteCallStruct[] calldata calls
    ) public view returns (uint[] memory amountsOut) {
      return _getAmountsOut(tokensLookupSize, inputAmount, calls);
    }

    function getAmountsOutLP(
        uint tokensLookupSize,
        uint inputAmount,
        QuoteCallStruct[] calldata calls,
        IPancakePair outputToken,
        uint token0BalanceIndex,
        uint token1BalanceIndex
    ) public view returns (uint token0Amount, uint token1Amount, uint lpTokenAmount) {
      uint[] memory amountsOut = _getAmountsOut(tokensLookupSize, inputAmount, calls);
      uint token0Balance = amountsOut[token0BalanceIndex];
      uint token1Balance = amountsOut[token1BalanceIndex];
      (uint token0Reserve, uint token1Reserve,) = outputToken.getReserves();
      uint totalSupply = outputToken.totalSupply();

      uint lpAmountOut = Math.min(
        token0Balance.mul(totalSupply).div(token0Reserve),
        token1Balance.mul(totalSupply).div(token1Reserve)
      );
      return (token0Balance, token1Balance, lpAmountOut);
    }

    function _doCalls(
        IERC20 inToken,
        uint256 inAmount,
        CallStruct[] calldata calls
    ) internal whenNotPaused {
        // Initial checks
        require(calls.length > 0, "!(calls.length > 0)");
        require(
            (msg.value != 0) == inToken.isETH(),
            "msg.value should be used only for ETH swap"
        );

        // Transfer inToken to address(this)
        if (!inToken.isETH()) {
            inToken.safeTransferFrom(msg.sender, address(this), inAmount);
        }

        // Execute swaps
        for (uint256 i = 0; i < calls.length; i++) {
            // If call is a swap
            require(isMember(calls[i].target), "!whitelisted");
            if (calls[i].inToken.isETH()) {
                (bool succeeded,) = calls[i].target.call{value: calls[i].amount}(
                    abi.encodePacked(
                        calls[i].selector,
                        calls[i].data
                    )
                );
                require(succeeded, "ETH Subswap failed");
            } else {
                _resetAllowances(calls[i].inToken, calls[i].amount, calls[i].target);
                uint subswapInAmount = Math.min(
                    calls[i].amount,
                    calls[i].inToken.universalBalanceOf(address(this))
                );
                uint256 minOutAmount = 1;
                (bool succeeded,) = calls[i].target.call(
                    abi.encodePacked(
                      calls[i].selector,
                      calls[i].prefix,
                      subswapInAmount,
                      minOutAmount,
                      calls[i].data
                    )
                );
                require(succeeded, "Subswap failed");
            }
        }
    }

    function swapToLP(
        IERC20 inToken,
        IERC20 outToken,
        uint256 inAmount,
        uint256 minOutAmount,
        uint256 guaranteedAmount,
        address payable referrer,
        CallStruct[] calldata calls,
        AddLiquidityCallStruct calldata addLiquidityCall
    ) public payable nonReentrant whenNotPaused returns (uint256 outAmount) {
        require(minOutAmount > 0, "!(minOutAmount > 0)");
        require(isMember(address(addLiquidityCall.router)), "!whitelisted");

        _doCalls(inToken, inAmount, calls);

        IERC20 token0 = IERC20(IPancakePair(address(outToken)).token0());
        IERC20 token1 = IERC20(IPancakePair(address(outToken)).token1());

        if (inToken.isETH()) {
          // IWETH9(addLiquidityCall.router.WETH())
          IWETH9(WETH).deposit{ value: inToken.universalBalanceOf(address(this)) }();
        }

        _resetAllowances(token0, token0.universalBalanceOf(address(this)), address(addLiquidityCall.router));
        _resetAllowances(token1, token1.universalBalanceOf(address(this)), address(addLiquidityCall.router));

        addLiquidityCall.router.addLiquidity(
          address(token0),
          address(token1),
          token0.universalBalanceOf(address(this)),
          token1.universalBalanceOf(address(this)),
          addLiquidityCall.amount0Min,
          addLiquidityCall.amount1Min,
          address(this),
          addLiquidityCall.deadline
        );

        // Transfer subtokens dust (if any) to user
        token0.universalTransfer(
            msg.sender,
            token0.universalBalanceOf(address(this))
        );
        token1.universalTransfer(
            msg.sender,
            token1.universalBalanceOf(address(this))
        );

        // Handle fees
        outAmount = outToken.universalBalanceOf(address(this));
        uint256 fee;
        uint256 referrerFee;
        (outAmount, fee, referrerFee) = _handleFees(
            outToken,
            outAmount,
            guaranteedAmount,
            referrer
        );

        // Closing checks
        require(
            outAmount >= minOutAmount,
            "Return amount less than the minimum required amount"
        );

        // Transfer outToken to user
        outToken.universalTransfer(msg.sender, outAmount);

        emit Order(msg.sender, inToken, outToken, inAmount, outAmount);
        emit Swapped(
            inToken,
            outToken,
            referrer,
            inAmount,
            outAmount,
            fee,
            referrerFee,
            true
        );
    }

    function swap(
        IERC20 inToken,
        IERC20 outToken,
        uint256 inAmount,
        uint256 minOutAmount,
        uint256 guaranteedAmount,
        address payable referrer,
        CallStruct[] calldata calls
    ) public payable nonReentrant whenNotPaused returns (uint256 outAmount) {
        require(minOutAmount > 0, "!(minOutAmount > 0)");

        _doCalls(inToken, inAmount, calls);

        // Handle fees
        outAmount = outToken.universalBalanceOf(address(this));
        uint256 fee;
        uint256 referrerFee;
        (outAmount, fee, referrerFee) = _handleFees(
            outToken,
            outAmount,
            guaranteedAmount,
            referrer
        );

        // Closing checks
        require(
            outAmount >= minOutAmount,
            "Return amount less than the minimum required amount"
        );

        // Transfer outToken to user
        outToken.universalTransfer(msg.sender, outAmount);

        emit Order(msg.sender, inToken, outToken, inAmount, outAmount);
        emit Swapped(
            inToken,
            outToken,
            referrer,
            inAmount,
            outAmount,
            fee,
            referrerFee,
            false
        );
    }

    function _handleFees(
        IERC20 toToken,
        uint256 outAmount,
        uint256 guaranteedAmount,
        address referrer
    )
        internal
        returns (
            uint256 realOutAmount,
            uint256 fee,
            uint256 referrerFee
        )
    {
        if (outAmount <= guaranteedAmount || feeRate == 0) {
            return (outAmount, 0, 0);
        }

        fee = outAmount.sub(guaranteedAmount).mul(feeRate).div(10000);

        if (
            referrer != address(0) &&
            referrer != msg.sender &&
            referrer != tx.origin
        ) {
            referrerFee = fee.mul(referrerFeeRate).div(10000);
            if (toToken.universalTransfer(referrer, referrerFee)) {
                outAmount = outAmount.sub(referrerFee);
                fee = fee.sub(referrerFee);
            } else {
                referrerFee = 0;
            }
        }

        if (toToken.universalTransfer(owner(), fee)) {
            outAmount = outAmount.sub(fee);
        }

        return (outAmount, fee, referrerFee);
    }

    function _resetAllowances(IERC20 token, uint256 amt, address spenderAddress)
        internal
    {
        token.safeApprove(spenderAddress, uint256(0));
        token.safeIncreaseAllowance(spenderAddress, amt);
    }

    function changeFeeRate(uint256 _feeRate) public onlyOwner {
        require(_feeRate <= 10000, "!safe - too high");
        uint256 oldFeeRate = feeRate;
        feeRate = _feeRate;
        emit FeeRateChanged(oldFeeRate, _feeRate);
    }

    function changeReferrerFeeRate(uint256 _referrerFeeRate) public onlyOwner {
        require(_referrerFeeRate <= 10000, "!safe - too high");
        uint256 oldReferrerFeeRate = referrerFeeRate;
        referrerFeeRate = _referrerFeeRate;
        emit ReferrerFeeRateChanged(oldReferrerFeeRate, _referrerFeeRate);
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

    receive() external payable {}
}

pragma solidity 0.6.12;

import "./SafeMath.sol";
import "./Address.sol";
import "../interfaces/IERC20.sol";

// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/SafeERC20.sol
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transfer.selector, to, value)
        );
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, value)
        );
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance =
            token.allowance(address(this), spender).add(value);
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance =
            token.allowance(address(this), spender).sub(
                value,
                "SafeERC20: decreased allowance below zero"
            );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata =
            address(token).functionCall(
                data,
                "SafeERC20: low-level call failed"
            );
        if (returndata.length > 0) {
            // Return data is optional
            // solhint-disable-next-line max-line-length
            require(
                abi.decode(returndata, (bool)),
                "SafeERC20: ERC20 operation did not succeed"
            );
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}

pragma solidity 0.6.12;

import "./Context.sol";

// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "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() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

pragma solidity 0.6.12;

import "./Context.sol";

// "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Pausable.sol";
contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() internal {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!_paused, "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(_paused, "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

pragma solidity ^0.6.12;

import "./SafeMath.sol";
import "../interfaces/IERC20.sol";
import "./SafeERC20.sol";

library UniversalERC20 {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    IERC20 private constant ZERO_ADDRESS =
        IERC20(0x0000000000000000000000000000000000000000);
    IERC20 private constant ETH_ADDRESS =
        IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);

    function universalTransfer(
        IERC20 token,
        address to,
        uint256 amount
    ) internal returns (bool) {
        if (amount == 0) {
            return false;
        }

        if (isETH(token)) {
            address(uint160(to)).transfer(amount);
        } else {
            token.safeTransfer(to, amount);
        }
        return true;
    }

    function universalTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 amount
    ) internal {
        if (amount == 0) {
            return;
        }

        if (isETH(token)) {
            require(
                from == msg.sender && msg.value >= amount,
                "Wrong useage of ETH.universalTransferFrom()"
            );
            if (to != address(this)) {
                address(uint160(to)).transfer(amount);
            }
            if (msg.value > amount) {
                msg.sender.transfer(msg.value.sub(amount));
            }
        } else {
            token.safeTransferFrom(from, to, amount);
        }
    }

    function universalTransferFromSenderToThis(IERC20 token, uint256 amount)
        internal
    {
        if (amount == 0) {
            return;
        }

        if (isETH(token)) {
            if (msg.value > amount) {
                // Return remainder if exist
                msg.sender.transfer(msg.value.sub(amount));
            }
        } else {
            token.safeTransferFrom(msg.sender, address(this), amount);
        }
    }

    function universalApprove(
        IERC20 token,
        address to,
        uint256 amount
    ) internal {
        if (!isETH(token)) {
            if (amount == 0) {
                token.safeApprove(to, 0);
                return;
            }

            uint256 allowance = token.allowance(address(this), to);
            if (allowance < amount) {
                if (allowance > 0) {
                    token.safeApprove(to, 0);
                }
                token.safeApprove(to, amount);
            }
        }
    }

    function universalBalanceOf(IERC20 token, address who)
        internal
        view
        returns (uint256)
    {
        if (isETH(token)) {
            return who.balance;
        } else {
            return token.balanceOf(who);
        }
    }

    function universalDecimals(IERC20 token) internal view returns (uint256) {
        if (isETH(token)) {
            return 18;
        }

        (bool success, bytes memory data) =
            address(token).staticcall.gas(10000)(
                abi.encodeWithSignature("decimals()")
            );
        if (!success || data.length == 0) {
            (success, data) = address(token).staticcall.gas(10000)(
                abi.encodeWithSignature("DECIMALS()")
            );
        }

        return (success && data.length > 0) ? abi.decode(data, (uint256)) : 18;
    }

    function isETH(IERC20 token) internal pure returns (bool) {
        return (address(token) == address(ZERO_ADDRESS) ||
            address(token) == address(ETH_ADDRESS));
    }

    function eq(IERC20 a, IERC20 b) internal pure returns (bool) {
        return a == b || (isETH(a) && isETH(b));
    }

    function notExist(IERC20 token) internal pure returns (bool) {
        return (address(token) == address(-1));
    }
}

pragma solidity 0.6.12;

// "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/ReentrancyGuard.sol";
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

pragma solidity 0.6.12;
import "./Ownable.sol";

/**
 * @title Whitelist
 * @author Alberto Cuesta Canada
 * @dev Implements a simple whitelist of addresses.
 */
// "https://github.com/HQ20/contracts/blob/6a4f166ca8ae0789955a33a0175edfa2dcb4b69f/contracts/access/Whitelist.sol"
contract Whitelist is Ownable {
    event MemberAdded(address member);
    event MemberRemoved(address member);

    mapping(address => bool) members;

    /**
     * @dev The contract constructor.
     */
    constructor() public Ownable() {}

    /**
     * @dev A method to verify whether an address is a member of the whitelist
     * @param _member The address to verify.
     * @return Whether the address is a member of the whitelist.
     */
    function isMember(address _member) public view returns (bool) {
        return members[_member];
    }

    /**
     * @dev A method to add a member to the whitelist
     * @param _member The member to add as a member.
     */
    function addMember(address _member) public onlyOwner {
        require(!isMember(_member), "Address is member already.");

        members[_member] = true;
        emit MemberAdded(_member);
    }

    /**
     * @dev A method to remove a member from the whitelist
     * @param _member The member to remove as a member.
     */
    function removeMember(address _member) public onlyOwner {
        require(isMember(_member), "Not member of whitelist.");

        delete members[_member];
        emit MemberRemoved(_member);
    }
}

pragma solidity 0.6.12;

import "./IPancakeRouter01.sol";

interface IPancakeRouter02 is IPancakeRouter01 {
    
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

}

pragma solidity >=0.5.0;

interface IPancakePair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

pragma solidity >=0.4.0;

interface IWETH9 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);

    function balanceOf(address) external view returns (uint);

    function allowance(address, address) external view returns (uint);

    receive() external payable;

    function deposit() external payable;

    function withdraw(uint wad) external;

    function totalSupply() external view returns (uint);

    function approve(address guy, uint wad) external returns (bool);

    function transfer(address dst, uint wad) external returns (bool);

    function transferFrom(address src, address dst, uint wad)
    external
    returns (bool);
}

pragma solidity >= 0.5.0;

interface ICurvePool {
    function get_dy(int128 i, int128 j, uint256 _dx) external view returns (uint256);
}

pragma solidity ^0.6.12;

// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/SafeMath.sol
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

pragma solidity 0.6.12;

// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/SafeERC20.sol";
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(
            address(this).balance >= amount,
            "Address: insufficient balance"
        );

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{value: amount}("");
        require(
            success,
            "Address: unable to send value, recipient may have reverted"
        );
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                value,
                "Address: low-level call with value failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(
            address(this).balance >= value,
            "Address: insufficient balance for call"
        );
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) =
            target.call{value: value}(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data)
        internal
        view
        returns (bytes memory)
    {
        return
            functionStaticCall(
                target,
                data,
                "Address: low-level static call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.3._
     */
    function functionDelegateCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return
            functionDelegateCall(
                target,
                data,
                "Address: low-level delegate call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.3._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

pragma solidity ^0.6.12;

// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol";
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

pragma solidity 0.6.12;

// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Context.sol
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

pragma solidity 0.6.12;

interface IPancakeRouter01 {
    function WAVAX() external pure returns (address payable);
   
    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
        external
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        );

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
	payable
        returns (
            uint256 amountA,
            uint256 amountETH,
            uint256 liquidity
        );

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function getAmountsOut(uint256 amountIn, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);

}

{
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"uint256","name":"_feeRate","type":"uint256"},{"internalType":"uint256","name":"_referrerFeeRate","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"oldFeeRate","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"newFeeRate","type":"uint256"}],"name":"FeeRateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"member","type":"address"}],"name":"MemberAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"member","type":"address"}],"name":"MemberRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"contract IERC20","name":"inToken","type":"address"},{"indexed":true,"internalType":"contract IERC20","name":"outToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"inAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"outAmount","type":"uint256"}],"name":"Order","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"oldReferrerFeeRate","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"newReferrerFeeRate","type":"uint256"}],"name":"ReferrerFeeRateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC20","name":"inToken","type":"address"},{"indexed":true,"internalType":"contract IERC20","name":"outToken","type":"address"},{"indexed":true,"internalType":"address","name":"referrer","type":"address"},{"indexed":false,"internalType":"uint256","name":"inAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"outAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"referrerFee","type":"uint256"},{"indexed":false,"internalType":"bool","name":"isLPSwap","type":"bool"}],"name":"Swapped","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_member","type":"address"}],"name":"addMember","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_feeRate","type":"uint256"}],"name":"changeFeeRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_referrerFeeRate","type":"uint256"}],"name":"changeReferrerFeeRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokensLookupSize","type":"uint256"},{"internalType":"uint256","name":"inputAmount","type":"uint256"},{"components":[{"internalType":"address","name":"router","type":"address"},{"internalType":"enum AutoSwap_02.RouterTypes","name":"routerType","type":"uint8"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"uint256","name":"inputTokenIndex","type":"uint256"},{"internalType":"uint256","name":"outputTokenIndex","type":"uint256"},{"internalType":"int128","name":"i","type":"int128"},{"internalType":"int128","name":"j","type":"int128"}],"internalType":"struct AutoSwap_02.QuoteCallStruct[]","name":"calls","type":"tuple[]"}],"name":"getAmountsOut","outputs":[{"internalType":"uint256[]","name":"amountsOut","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokensLookupSize","type":"uint256"},{"internalType":"uint256","name":"inputAmount","type":"uint256"},{"components":[{"internalType":"address","name":"router","type":"address"},{"internalType":"enum AutoSwap_02.RouterTypes","name":"routerType","type":"uint8"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"uint256","name":"inputTokenIndex","type":"uint256"},{"internalType":"uint256","name":"outputTokenIndex","type":"uint256"},{"internalType":"int128","name":"i","type":"int128"},{"internalType":"int128","name":"j","type":"int128"}],"internalType":"struct AutoSwap_02.QuoteCallStruct[]","name":"calls","type":"tuple[]"},{"internalType":"contract IPancakePair","name":"outputToken","type":"address"},{"internalType":"uint256","name":"token0BalanceIndex","type":"uint256"},{"internalType":"uint256","name":"token1BalanceIndex","type":"uint256"}],"name":"getAmountsOutLP","outputs":[{"internalType":"uint256","name":"token0Amount","type":"uint256"},{"internalType":"uint256","name":"token1Amount","type":"uint256"},{"internalType":"uint256","name":"lpTokenAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_member","type":"address"}],"name":"isMember","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"referrerFeeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_member","type":"address"}],"name":"removeMember","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"inToken","type":"address"},{"internalType":"contract IERC20","name":"outToken","type":"address"},{"internalType":"uint256","name":"inAmount","type":"uint256"},{"internalType":"uint256","name":"minOutAmount","type":"uint256"},{"internalType":"uint256","name":"guaranteedAmount","type":"uint256"},{"internalType":"address payable","name":"referrer","type":"address"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"contract IERC20","name":"inToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes4","name":"selector","type":"bytes4"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bytes","name":"prefix","type":"bytes"}],"internalType":"struct AutoSwap_02.CallStruct[]","name":"calls","type":"tuple[]"}],"name":"swap","outputs":[{"internalType":"uint256","name":"outAmount","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"inToken","type":"address"},{"internalType":"contract IERC20","name":"outToken","type":"address"},{"internalType":"uint256","name":"inAmount","type":"uint256"},{"internalType":"uint256","name":"minOutAmount","type":"uint256"},{"internalType":"uint256","name":"guaranteedAmount","type":"uint256"},{"internalType":"address payable","name":"referrer","type":"address"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"contract IERC20","name":"inToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes4","name":"selector","type":"bytes4"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bytes","name":"prefix","type":"bytes"}],"internalType":"struct AutoSwap_02.CallStruct[]","name":"calls","type":"tuple[]"},{"components":[{"internalType":"contract IPancakeRouter02","name":"router","type":"address"},{"internalType":"uint256","name":"amount0Min","type":"uint256"},{"internalType":"uint256","name":"amount1Min","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"internalType":"struct AutoSwap_02.AddLiquidityCallStruct","name":"addLiquidityCall","type":"tuple"}],"name":"swapToLP","outputs":[{"internalType":"uint256","name":"outAmount","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0000000000000000000000009fffe8d0336b87b60ac847465be7459c1289df7300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _owner (address): 0x9fffe8d0336b87b60ac847465be7459c1289df73
Arg [1] : _feeRate (uint256): 0
Arg [2] : _referrerFeeRate (uint256): 0

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000009fffe8d0336b87b60ac847465be7459c1289df73
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000000