Contract 0x7C5A661069A25e94a71E03c75A58D7cf765C2C75

// 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;

    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())
            .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 WETH() 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",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"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":[{"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"}]

60806040523480156200001157600080fd5b50604051620052e9380380620052e9833981810160405281019062000037919062000337565b6000620000496200013160201b60201c565b9050806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a350600180819055506000600260006101000a81548160ff0219169083151502179055506200011a836200013960201b60201c565b8160048190555080600581905550505050620004fe565b600033905090565b620001496200013160201b60201c565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614620001d9576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620001d09062000459565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156200024c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620002439062000437565b60405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a3806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b6000815190506200031a81620004ca565b92915050565b6000815190506200033181620004e4565b92915050565b6000806000606084860312156200034d57600080fd5b60006200035d8682870162000309565b9350506020620003708682870162000320565b9250506040620003838682870162000320565b9150509250925092565b60006200039c6026836200047b565b91507f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008301527f64647265737300000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000620004046020836200047b565b91507f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726000830152602082019050919050565b6000602082019050818103600083015262000452816200038d565b9050919050565b600060208201905081810360008301526200047481620003f5565b9050919050565b600082825260208201905092915050565b60006200049982620004a0565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b620004d5816200048c565b8114620004e157600080fd5b50565b620004ef81620004c0565b8114620004fb57600080fd5b50565b614ddb806200050e6000396000f3fe6080604052600436106101025760003560e01c8063715018a611610095578063978bbdb911610064578063978bbdb914610302578063a230c5241461032d578063affca9321461036a578063ca6d56dc14610393578063f2fde38b146103bc57610109565b8063715018a61461027e5780637e5bf1a9146102955780638456cb59146102c05780638da5cb5b146102d757610109565b80633fd634af116100d15780633fd634af146101bd578063422596c0146101ed578063595d0397146102165780635c975abb1461025357610109565b80630b1ca49a1461010e5780633188c4e2146101375780633d5628fc146101765780633f4ba83a146101a657610109565b3661010957005b600080fd5b34801561011a57600080fd5b506101356004803603810190610130919061356b565b6103e5565b005b34801561014357600080fd5b5061015e600480360381019061015991906139b2565b61054b565b60405161016d93929190614888565b60405180910390f35b610190600480360381019061018b919061375c565b61072b565b60405161019d9190614812565b60405180910390f35b3480156101b257600080fd5b506101bb610ec1565b005b6101d760048036038101906101d291906136a2565b610f60565b6040516101e49190614812565b60405180910390f35b3480156101f957600080fd5b50610214600480360381019061020f91906138f4565b61121c565b005b34801561022257600080fd5b5061023d60048036038101906102389190613946565b611336565b60405161024a91906144dc565b60405180910390f35b34801561025f57600080fd5b5061026861134e565b60405161027591906144fe565b60405180910390f35b34801561028a57600080fd5b50610293611365565b005b3480156102a157600080fd5b506102aa6114b8565b6040516102b79190614812565b60405180910390f35b3480156102cc57600080fd5b506102d56114be565b005b3480156102e357600080fd5b506102ec61155d565b6040516102f9919061439f565b60405180910390f35b34801561030e57600080fd5b50610317611586565b6040516103249190614812565b60405180910390f35b34801561033957600080fd5b50610354600480360381019061034f919061356b565b61158c565b60405161036191906144fe565b60405180910390f35b34801561037657600080fd5b50610391600480360381019061038c91906138f4565b6115e2565b005b34801561039f57600080fd5b506103ba60048036038101906103b5919061356b565b6116fc565b005b3480156103c857600080fd5b506103e360048036038101906103de919061356b565b61186c565b005b6103ed611a2e565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff161461047a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610471906146b2565b60405180910390fd5b6104838161158c565b6104c2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104b990614652565b60405180910390fd5b600360008273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81549060ff02191690557f6e76fb4c77256006d9c38ec7d82b45a8c8f3c27b1d6766fffc42dfb8de68449281604051610540919061439f565b60405180910390a150565b6000806000606061055e8b8b8b8b611a36565b9050600081878151811061056e57fe5b60200260200101519050600082878151811061058657fe5b602002602001015190506000808a73ffffffffffffffffffffffffffffffffffffffff16630902f1ac6040518163ffffffff1660e01b815260040160606040518083038186803b1580156105d957600080fd5b505afa1580156105ed573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061061191906138a5565b506dffffffffffffffffffffffffffff1691506dffffffffffffffffffffffffffff16915060008b73ffffffffffffffffffffffffffffffffffffffff166318160ddd6040518163ffffffff1660e01b815260040160206040518083038186803b15801561067e57600080fd5b505afa158015610692573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106b6919061391d565b9050600061070c6106e2856106d4858a611eda90919063ffffffff16565b611f4a90919063ffffffff16565b610707856106f9868a611eda90919063ffffffff16565b611f4a90919063ffffffff16565b611f94565b9050858582995099509950505050505050509750975097945050505050565b600060026001541415610773576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161076a906147b2565b60405180910390fd5b6002600181905550600260009054906101000a900460ff16156107cb576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107c290614632565b60405180910390fd5b6000871161080e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610805906147d2565b60405180910390fd5b610829826000016020810190610824919061382a565b61158c565b610868576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161085f906146f2565b60405180910390fd5b6108748a898686611fad565b60008973ffffffffffffffffffffffffffffffffffffffff16630dfe16816040518163ffffffff1660e01b815260040160206040518083038186803b1580156108bc57600080fd5b505afa1580156108d0573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108f49190613594565b905060008a73ffffffffffffffffffffffffffffffffffffffff1663d21220a76040518163ffffffff1660e01b815260040160206040518083038186803b15801561093e57600080fd5b505afa158015610952573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109769190613594565b90506109978c73ffffffffffffffffffffffffffffffffffffffff1661260f565b15610ab5578360000160208101906109af919061382a565b73ffffffffffffffffffffffffffffffffffffffff1663ad5c46486040518163ffffffff1660e01b815260040160206040518083038186803b1580156109f457600080fd5b505afa158015610a08573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a2c91906135bd565b73ffffffffffffffffffffffffffffffffffffffff1663d0e30db0610a70308f73ffffffffffffffffffffffffffffffffffffffff1661269190919063ffffffff16565b6040518263ffffffff1660e01b81526004016000604051808303818588803b158015610a9b57600080fd5b505af1158015610aaf573d6000803e3d6000fd5b50505050505b610afa82610ae2308573ffffffffffffffffffffffffffffffffffffffff1661269190919063ffffffff16565b866000016020810190610af5919061382a565b612752565b610b3f81610b27308473ffffffffffffffffffffffffffffffffffffffff1661269190919063ffffffff16565b866000016020810190610b3a919061382a565b612752565b836000016020810190610b52919061382a565b73ffffffffffffffffffffffffffffffffffffffff1663e8e337008383610b98308773ffffffffffffffffffffffffffffffffffffffff1661269190919063ffffffff16565b610bc1308773ffffffffffffffffffffffffffffffffffffffff1661269190919063ffffffff16565b89602001358a60400135308c606001356040518963ffffffff1660e01b8152600401610bf4989796959493929190614435565b606060405180830381600087803b158015610c0e57600080fd5b505af1158015610c22573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610c469190613a59565b505050610c9c33610c76308573ffffffffffffffffffffffffffffffffffffffff1661269190919063ffffffff16565b8473ffffffffffffffffffffffffffffffffffffffff166127ae9092919063ffffffff16565b50610cf033610cca308473ffffffffffffffffffffffffffffffffffffffff1661269190919063ffffffff16565b8373ffffffffffffffffffffffffffffffffffffffff166127ae9092919063ffffffff16565b50610d1a308c73ffffffffffffffffffffffffffffffffffffffff1661269190919063ffffffff16565b9250600080610d2b8d868c8c612853565b8093508194508297505050508a851015610d7a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d7190614672565b60405180910390fd5b610da533868f73ffffffffffffffffffffffffffffffffffffffff166127ae9092919063ffffffff16565b508c73ffffffffffffffffffffffffffffffffffffffff168e73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f4ec237690cd79c8ab7ec9b0747f20cb9e9a58b89bd4e09312f5773ab546bee4c8f89604051610e1c92919061485f565b60405180910390a48873ffffffffffffffffffffffffffffffffffffffff168d73ffffffffffffffffffffffffffffffffffffffff168f73ffffffffffffffffffffffffffffffffffffffff167f44ccebb1f8242fcdaee7626f1c0ba52d3d797ca0170adf18f5c3faa5e6c70f128f8987876001604051610ea19594939291906148bf565b60405180910390a450505050600180819055509998505050505050505050565b610ec9611a2e565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610f56576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f4d906146b2565b60405180910390fd5b610f5e612a4b565b565b600060026001541415610fa8576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f9f906147b2565b60405180910390fd5b6002600181905550600260009054906101000a900460ff1615611000576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ff790614632565b60405180910390fd5b60008611611043576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161103a906147d2565b60405180910390fd5b61104f89888585611fad565b611078308973ffffffffffffffffffffffffffffffffffffffff1661269190919063ffffffff16565b90506000806110898a848989612853565b809350819450829550505050878310156110d8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016110cf90614672565b60405180910390fd5b61110333848c73ffffffffffffffffffffffffffffffffffffffff166127ae9092919063ffffffff16565b508973ffffffffffffffffffffffffffffffffffffffff168b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f4ec237690cd79c8ab7ec9b0747f20cb9e9a58b89bd4e09312f5773ab546bee4c8c8760405161117a92919061485f565b60405180910390a48573ffffffffffffffffffffffffffffffffffffffff168a73ffffffffffffffffffffffffffffffffffffffff168c73ffffffffffffffffffffffffffffffffffffffff167f44ccebb1f8242fcdaee7626f1c0ba52d3d797ca0170adf18f5c3faa5e6c70f128c87878760006040516111ff9594939291906148bf565b60405180910390a450506001808190555098975050505050505050565b611224611a2e565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146112b1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112a8906146b2565b60405180910390fd5b6127108111156112f6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112ed90614732565b60405180910390fd5b600060055490508160058190555081817f1cd30194bbb4e8743cc21dd26f5d4d8e748e8e121a7ea98fddaf3f03dd1350fe60405160405180910390a35050565b606061134485858585611a36565b9050949350505050565b6000600260009054906101000a900460ff16905090565b61136d611a2e565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146113fa576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113f1906146b2565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a360008060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550565b60055481565b6114c6611a2e565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614611553576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161154a906146b2565b60405180910390fd5b61155b612af5565b565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b60045481565b6000600360008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff169050919050565b6115ea611a2e565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614611677576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161166e906146b2565b60405180910390fd5b6127108111156116bc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116b390614732565b60405180910390fd5b600060045490508160048190555081817fb9ffe02e89fee6f5544ee152a08c2cafbc3a4a89a66737ef42115dcd508aea1060405160405180910390a35050565b611704611a2e565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614611791576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611788906146b2565b60405180910390fd5b61179a8161158c565b156117da576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016117d190614772565b60405180910390fd5b6001600360008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055507fb251eb052afc73ffd02ffe85ad79990a8b3fed60d76dbc2fa2fdd7123dffd91481604051611861919061439f565b60405180910390a150565b611874611a2e565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614611901576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016118f8906146b2565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415611971576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161196890614592565b60405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a3806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b600033905090565b6060808567ffffffffffffffff81118015611a5057600080fd5b50604051908082528060200260200182016040528015611a7f5781602001602082028036833780820191505090505b5090508481600081518110611a9057fe5b60200260200101818152505060005b84849050811015611ecd57611ae2858583818110611ab957fe5b9050602002810190611acb91906149e4565b6000016020810190611add919061356b565b61158c565b611b21576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611b18906146f2565b60405180910390fd5b6000611b82868684818110611b3257fe5b9050602002810190611b4491906149e4565b6040013584888886818110611b5557fe5b9050602002810190611b6791906149e4565b6080013581518110611b7557fe5b6020026020010151611f94565b90508083878785818110611b9257fe5b9050602002810190611ba491906149e4565b6080013581518110611bb257fe5b60200260200101818151039150818152505060006001811115611bd157fe5b868684818110611bdd57fe5b9050602002810190611bef91906149e4565b6020016020810190611c019190613853565b6001811115611c0c57fe5b1415611d5f576060868684818110611c2057fe5b9050602002810190611c3291906149e4565b6000016020810190611c44919061356b565b73ffffffffffffffffffffffffffffffffffffffff1663d06ca61f83898987818110611c6c57fe5b9050602002810190611c7e91906149e4565b8060600190611c8d9190614912565b6040518463ffffffff1660e01b8152600401611cab9392919061482d565b60006040518083038186803b158015611cc357600080fd5b505afa158015611cd7573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f82011682018060405250810190611d0091906135e6565b905080600182510381518110611d1257fe5b602002602001015184888886818110611d2757fe5b9050602002810190611d3991906149e4565b60a0013581518110611d4757fe5b60200260200101818151019150818152505050611ebf565b6000868684818110611d6d57fe5b9050602002810190611d7f91906149e4565b6000016020810190611d91919061356b565b73ffffffffffffffffffffffffffffffffffffffff16635e0d443f888886818110611db857fe5b9050602002810190611dca91906149e4565b60c0016020810190611ddc919061387c565b898987818110611de857fe5b9050602002810190611dfa91906149e4565b60e0016020810190611e0c919061387c565b856040518463ffffffff1660e01b8152600401611e2b93929190614519565b60206040518083038186803b158015611e4357600080fd5b505afa158015611e57573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611e7b919061391d565b90508084888886818110611e8b57fe5b9050602002810190611e9d91906149e4565b60a0013581518110611eab57fe5b602002602001018181510191508181525050505b508080600101915050611a9f565b5080915050949350505050565b600080831415611eed5760009050611f44565b6000828402905082848281611efe57fe5b0414611f3f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611f3690614692565b60405180910390fd5b809150505b92915050565b6000611f8c83836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f000000000000815250612ba0565b905092915050565b6000818310611fa35781611fa5565b825b905092915050565b600260009054906101000a900460ff1615611ffd576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611ff490614632565b60405180910390fd5b60008282905011612043576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161203a906146d2565b60405180910390fd5b6120628473ffffffffffffffffffffffffffffffffffffffff1661260f565b151560003414151515146120ab576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016120a2906145f2565b60405180910390fd5b6120ca8473ffffffffffffffffffffffffffffffffffffffff1661260f565b6120fc576120fb3330858773ffffffffffffffffffffffffffffffffffffffff16612c01909392919063ffffffff16565b5b60005b828290508110156126085761214283838381811061211957fe5b905060200281019061212b91906149c0565b600001602081019061213d919061356b565b61158c565b612181576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612178906146f2565b60405180910390fd5b6121cf83838381811061219057fe5b90506020028101906121a291906149c0565b60200160208101906121b49190613679565b73ffffffffffffffffffffffffffffffffffffffff1661260f565b156123555760008383838181106121e257fe5b90506020028101906121f491906149c0565b6000016020810190612206919061356b565b73ffffffffffffffffffffffffffffffffffffffff1684848481811061222857fe5b905060200281019061223a91906149c0565b6040013585858581811061224a57fe5b905060200281019061225c91906149c0565b606001602081019061226e9190613650565b86868681811061227a57fe5b905060200281019061228c91906149c0565b806080019061229b9190614969565b6040516020016122ad93929190614303565b6040516020818303038152906040526040516122c99190614388565b60006040518083038185875af1925050503d8060008114612306576040519150601f19603f3d011682016040523d82523d6000602084013e61230b565b606091505b505090508061234f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161234690614712565b60405180910390fd5b506125fb565b6123df83838381811061236457fe5b905060200281019061237691906149c0565b60200160208101906123889190613679565b84848481811061239457fe5b90506020028101906123a691906149c0565b604001358585858181106123b657fe5b90506020028101906123c891906149c0565b60000160208101906123da919061356b565b612752565b60006124638484848181106123f057fe5b905060200281019061240291906149c0565b6040013561245e3087878781811061241657fe5b905060200281019061242891906149c0565b602001602081019061243a9190613679565b73ffffffffffffffffffffffffffffffffffffffff1661269190919063ffffffff16565b611f94565b9050600060019050600085858581811061247957fe5b905060200281019061248b91906149c0565b600001602081019061249d919061356b565b73ffffffffffffffffffffffffffffffffffffffff168686868181106124bf57fe5b90506020028101906124d191906149c0565b60600160208101906124e39190613650565b8787878181106124ef57fe5b905060200281019061250191906149c0565b8060a001906125109190614969565b86868b8b8b81811061251e57fe5b905060200281019061253091906149c0565b806080019061253f9190614969565b604051602001612555979695949392919061432d565b6040516020818303038152906040526040516125719190614388565b6000604051808303816000865af19150503d80600081146125ae576040519150601f19603f3d011682016040523d82523d6000602084013e6125b3565b606091505b50509050806125f7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016125ee906145b2565b60405180910390fd5b5050505b80806001019150506120ff565b5050505050565b60008073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16148061268a575073eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16145b9050919050565b600061269c8361260f565b156126c0578173ffffffffffffffffffffffffffffffffffffffff1631905061274c565b8273ffffffffffffffffffffffffffffffffffffffff166370a08231836040518263ffffffff1660e01b81526004016126f9919061439f565b60206040518083038186803b15801561271157600080fd5b505afa158015612725573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612749919061391d565b90505b92915050565b61277e8160008573ffffffffffffffffffffffffffffffffffffffff16612c8a9092919063ffffffff16565b6127a981838573ffffffffffffffffffffffffffffffffffffffff16612de89092919063ffffffff16565b505050565b6000808214156127c1576000905061284c565b6127ca8461260f565b1561281b578273ffffffffffffffffffffffffffffffffffffffff166108fc839081150290604051600060405180830381858888f19350505050158015612815573d6000803e3d6000fd5b50612847565b61284683838673ffffffffffffffffffffffffffffffffffffffff16612f109092919063ffffffff16565b5b600190505b9392505050565b6000806000848611158061286957506000600454145b1561287d5785600080925092509250612a41565b6128b86127106128aa60045461289c898b612f9690919063ffffffff16565b611eda90919063ffffffff16565b611f4a90919063ffffffff16565b9150600073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff161415801561292357503373ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1614155b801561295b57503273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1614155b156129f05761298961271061297b60055485611eda90919063ffffffff16565b611f4a90919063ffffffff16565b90506129b684828973ffffffffffffffffffffffffffffffffffffffff166127ae9092919063ffffffff16565b156129ea576129ce8187612f9690919063ffffffff16565b95506129e38183612f9690919063ffffffff16565b91506129ef565b600090505b5b612a226129fb61155d565b838973ffffffffffffffffffffffffffffffffffffffff166127ae9092919063ffffffff16565b15612a3d57612a3a8287612f9690919063ffffffff16565b95505b8592505b9450945094915050565b600260009054906101000a900460ff16612a9a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612a9190614572565b60405180910390fd5b6000600260006101000a81548160ff0219169083151502179055507f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa612ade611a2e565b604051612aeb91906143ba565b60405180910390a1565b600260009054906101000a900460ff1615612b45576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612b3c90614632565b60405180910390fd5b6001600260006101000a81548160ff0219169083151502179055507f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258612b89611a2e565b604051612b9691906143ba565b60405180910390a1565b60008083118290612be7576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612bde9190614550565b60405180910390fd5b506000838581612bf357fe5b049050809150509392505050565b612c84846323b872dd60e01b858585604051602401612c22939291906143fe565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050612fe0565b50505050565b6000811480612d23575060008373ffffffffffffffffffffffffffffffffffffffff1663dd62ed3e30856040518363ffffffff1660e01b8152600401612cd19291906143d5565b60206040518083038186803b158015612ce957600080fd5b505afa158015612cfd573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612d21919061391d565b145b612d62576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612d59906147f2565b60405180910390fd5b612de38363095ea7b360e01b8484604051602401612d819291906144b3565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050612fe0565b505050565b6000612e87828573ffffffffffffffffffffffffffffffffffffffff1663dd62ed3e30876040518363ffffffff1660e01b8152600401612e299291906143d5565b60206040518083038186803b158015612e4157600080fd5b505afa158015612e55573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612e79919061391d565b6130a790919063ffffffff16565b9050612f0a8463095ea7b360e01b8584604051602401612ea89291906144b3565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050612fe0565b50505050565b612f918363a9059cbb60e01b8484604051602401612f2f9291906144b3565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050612fe0565b505050565b6000612fd883836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f7700008152506130fc565b905092915050565b6060613042826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166131579092919063ffffffff16565b90506000815111156130a257808060200190518101906130629190613627565b6130a1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161309890614792565b60405180910390fd5b5b505050565b6000808284019050838110156130f2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016130e9906145d2565b60405180910390fd5b8091505092915050565b6000838311158290613144576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161313b9190614550565b60405180910390fd5b5060008385039050809150509392505050565b6060613166848460008561316f565b90509392505050565b6060824710156131b4576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016131ab90614612565b60405180910390fd5b6131bd85613284565b6131fc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016131f390614752565b60405180910390fd5b600060608673ffffffffffffffffffffffffffffffffffffffff1685876040516132269190614388565b60006040518083038185875af1925050503d8060008114613263576040519150601f19603f3d011682016040523d82523d6000602084013e613268565b606091505b5091509150613278828286613297565b92505050949350505050565b600080823b905060008111915050919050565b606083156132a7578290506132f7565b6000835111156132ba5782518084602001fd5b816040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016132ee9190614550565b60405180910390fd5b9392505050565b60008135905061330d81614c98565b92915050565b60008151905061332281614c98565b92915050565b60008135905061333781614caf565b92915050565b60008151905061334c81614caf565b92915050565b60008083601f84011261336457600080fd5b8235905067ffffffffffffffff81111561337d57600080fd5b60208301915083602082028301111561339557600080fd5b9250929050565b60008083601f8401126133ae57600080fd5b8235905067ffffffffffffffff8111156133c757600080fd5b6020830191508360208202830111156133df57600080fd5b9250929050565b600082601f8301126133f757600080fd5b815161340a61340582614a36565b614a09565b9150818183526020840193506020810190508385602084028201111561342f57600080fd5b60005b8381101561345f57816134458882613541565b845260208401935060208301925050600181019050613432565b5050505092915050565b60008151905061347881614cc6565b92915050565b60008135905061348d81614cdd565b92915050565b6000813590506134a281614cf4565b92915050565b6000813590506134b781614d0b565b92915050565b6000813590506134cc81614d22565b92915050565b6000813590506134e181614d39565b92915050565b6000813590506134f681614d49565b92915050565b60006080828403121561350e57600080fd5b81905092915050565b60008151905061352681614d60565b92915050565b60008135905061353b81614d77565b92915050565b60008151905061355081614d77565b92915050565b60008151905061356581614d8e565b92915050565b60006020828403121561357d57600080fd5b600061358b848285016132fe565b91505092915050565b6000602082840312156135a657600080fd5b60006135b484828501613313565b91505092915050565b6000602082840312156135cf57600080fd5b60006135dd8482850161333d565b91505092915050565b6000602082840312156135f857600080fd5b600082015167ffffffffffffffff81111561361257600080fd5b61361e848285016133e6565b91505092915050565b60006020828403121561363957600080fd5b600061364784828501613469565b91505092915050565b60006020828403121561366257600080fd5b60006136708482850161347e565b91505092915050565b60006020828403121561368b57600080fd5b600061369984828501613493565b91505092915050565b60008060008060008060008060e0898b0312156136be57600080fd5b60006136cc8b828c01613493565b98505060206136dd8b828c01613493565b97505060406136ee8b828c0161352c565b96505060606136ff8b828c0161352c565b95505060806137108b828c0161352c565b94505060a06137218b828c01613328565b93505060c089013567ffffffffffffffff81111561373e57600080fd5b61374a8b828c01613352565b92509250509295985092959890939650565b60008060008060008060008060006101608a8c03121561377b57600080fd5b60006137898c828d01613493565b995050602061379a8c828d01613493565b98505060406137ab8c828d0161352c565b97505060606137bc8c828d0161352c565b96505060806137cd8c828d0161352c565b95505060a06137de8c828d01613328565b94505060c08a013567ffffffffffffffff8111156137fb57600080fd5b6138078c828d01613352565b935093505060e061381a8c828d016134fc565b9150509295985092959850929598565b60006020828403121561383c57600080fd5b600061384a848285016134bd565b91505092915050565b60006020828403121561386557600080fd5b6000613873848285016134d2565b91505092915050565b60006020828403121561388e57600080fd5b600061389c848285016134e7565b91505092915050565b6000806000606084860312156138ba57600080fd5b60006138c886828701613517565b93505060206138d986828701613517565b92505060406138ea86828701613556565b9150509250925092565b60006020828403121561390657600080fd5b60006139148482850161352c565b91505092915050565b60006020828403121561392f57600080fd5b600061393d84828501613541565b91505092915050565b6000806000806060858703121561395c57600080fd5b600061396a8782880161352c565b945050602061397b8782880161352c565b935050604085013567ffffffffffffffff81111561399857600080fd5b6139a48782880161339c565b925092505092959194509250565b600080600080600080600060c0888a0312156139cd57600080fd5b60006139db8a828b0161352c565b97505060206139ec8a828b0161352c565b965050604088013567ffffffffffffffff811115613a0957600080fd5b613a158a828b0161339c565b95509550506060613a288a828b016134a8565b9350506080613a398a828b0161352c565b92505060a0613a4a8a828b0161352c565b91505092959891949750929550565b600080600060608486031215613a6e57600080fd5b6000613a7c86828701613541565b9350506020613a8d86828701613541565b9250506040613a9e86828701613541565b9150509250925092565b6000613ab48383613ae7565b60208301905092915050565b6000613acc83836142ce565b60208301905092915050565b613ae181614bfb565b82525050565b613af081614b08565b82525050565b613aff81614b08565b82525050565b6000613b118385614ab3565b9350613b1c82614a5e565b8060005b85811015613b5557613b328284614af1565b613b3c8882613aa8565b9750613b4783614a99565b925050600181019050613b20565b5085925050509392505050565b6000613b6d82614a78565b613b778185614ac4565b9350613b8283614a68565b8060005b83811015613bb3578151613b9a8882613ac0565b9750613ba583614aa6565b925050600181019050613b86565b5085935050505092915050565b613bc981614b2c565b82525050565b613be0613bdb82614b38565b614c73565b82525050565b6000613bf28385614ad5565b9350613bff838584614c31565b82840190509392505050565b6000613c1682614a83565b613c208185614ad5565b9350613c30818560208601614c40565b80840191505092915050565b613c4581614b9a565b82525050565b6000613c5682614a8e565b613c608185614ae0565b9350613c70818560208601614c40565b613c7981614c87565b840191505092915050565b6000613c91601483614ae0565b91507f5061757361626c653a206e6f74207061757365640000000000000000000000006000830152602082019050919050565b6000613cd1602683614ae0565b91507f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008301527f64647265737300000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000613d37600e83614ae0565b91507f53756273776170206661696c65640000000000000000000000000000000000006000830152602082019050919050565b6000613d77601b83614ae0565b91507f536166654d6174683a206164646974696f6e206f766572666c6f7700000000006000830152602082019050919050565b6000613db7602a83614ae0565b91507f6d73672e76616c75652073686f756c642062652075736564206f6e6c7920666f60008301527f72204554482073776170000000000000000000000000000000000000000000006020830152604082019050919050565b6000613e1d602683614ae0565b91507f416464726573733a20696e73756666696369656e742062616c616e636520666f60008301527f722063616c6c00000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000613e83601083614ae0565b91507f5061757361626c653a20706175736564000000000000000000000000000000006000830152602082019050919050565b6000613ec3601883614ae0565b91507f4e6f74206d656d626572206f662077686974656c6973742e00000000000000006000830152602082019050919050565b6000613f03603383614ae0565b91507f52657475726e20616d6f756e74206c657373207468616e20746865206d696e6960008301527f6d756d20726571756972656420616d6f756e74000000000000000000000000006020830152604082019050919050565b6000613f69602183614ae0565b91507f536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f60008301527f77000000000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000613fcf602083614ae0565b91507f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726000830152602082019050919050565b600061400f601383614ae0565b91507f212863616c6c732e6c656e677468203e203029000000000000000000000000006000830152602082019050919050565b600061404f600c83614ae0565b91507f2177686974656c697374656400000000000000000000000000000000000000006000830152602082019050919050565b600061408f601283614ae0565b91507f4554482053756273776170206661696c656400000000000000000000000000006000830152602082019050919050565b60006140cf601083614ae0565b91507f2173616665202d20746f6f2068696768000000000000000000000000000000006000830152602082019050919050565b600061410f601d83614ae0565b91507f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006000830152602082019050919050565b600061414f601a83614ae0565b91507f41646472657373206973206d656d62657220616c72656164792e0000000000006000830152602082019050919050565b600061418f602a83614ae0565b91507f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008301527f6f742073756363656564000000000000000000000000000000000000000000006020830152604082019050919050565b60006141f5601f83614ae0565b91507f5265656e7472616e637947756172643a207265656e7472616e742063616c6c006000830152602082019050919050565b6000614235601383614ae0565b91507f21286d696e4f7574416d6f756e74203e203029000000000000000000000000006000830152602082019050919050565b6000614275603683614ae0565b91507f5361666545524332303a20617070726f76652066726f6d206e6f6e2d7a65726f60008301527f20746f206e6f6e2d7a65726f20616c6c6f77616e6365000000000000000000006020830152604082019050919050565b6142d781614be1565b82525050565b6142e681614be1565b82525050565b6142fd6142f882614be1565b614c7d565b82525050565b600061430f8286613bcf565b600482019150614320828486613be6565b9150819050949350505050565b6000614339828a613bcf565b60048201915061434a82888a613be6565b915061435682876142ec565b60208201915061436682866142ec565b602082019150614377828486613be6565b915081905098975050505050505050565b60006143948284613c0b565b915081905092915050565b60006020820190506143b46000830184613af6565b92915050565b60006020820190506143cf6000830184613ad8565b92915050565b60006040820190506143ea6000830185613af6565b6143f76020830184613af6565b9392505050565b60006060820190506144136000830186613af6565b6144206020830185613af6565b61442d60408301846142dd565b949350505050565b60006101008201905061444b600083018b613af6565b614458602083018a613af6565b61446560408301896142dd565b61447260608301886142dd565b61447f60808301876142dd565b61448c60a08301866142dd565b61449960c0830185613ad8565b6144a660e08301846142dd565b9998505050505050505050565b60006040820190506144c86000830185613af6565b6144d560208301846142dd565b9392505050565b600060208201905081810360008301526144f68184613b62565b905092915050565b60006020820190506145136000830184613bc0565b92915050565b600060608201905061452e6000830186613c3c565b61453b6020830185613c3c565b61454860408301846142dd565b949350505050565b6000602082019050818103600083015261456a8184613c4b565b905092915050565b6000602082019050818103600083015261458b81613c84565b9050919050565b600060208201905081810360008301526145ab81613cc4565b9050919050565b600060208201905081810360008301526145cb81613d2a565b9050919050565b600060208201905081810360008301526145eb81613d6a565b9050919050565b6000602082019050818103600083015261460b81613daa565b9050919050565b6000602082019050818103600083015261462b81613e10565b9050919050565b6000602082019050818103600083015261464b81613e76565b9050919050565b6000602082019050818103600083015261466b81613eb6565b9050919050565b6000602082019050818103600083015261468b81613ef6565b9050919050565b600060208201905081810360008301526146ab81613f5c565b9050919050565b600060208201905081810360008301526146cb81613fc2565b9050919050565b600060208201905081810360008301526146eb81614002565b9050919050565b6000602082019050818103600083015261470b81614042565b9050919050565b6000602082019050818103600083015261472b81614082565b9050919050565b6000602082019050818103600083015261474b816140c2565b9050919050565b6000602082019050818103600083015261476b81614102565b9050919050565b6000602082019050818103600083015261478b81614142565b9050919050565b600060208201905081810360008301526147ab81614182565b9050919050565b600060208201905081810360008301526147cb816141e8565b9050919050565b600060208201905081810360008301526147eb81614228565b9050919050565b6000602082019050818103600083015261480b81614268565b9050919050565b600060208201905061482760008301846142dd565b92915050565b600060408201905061484260008301866142dd565b8181036020830152614855818486613b05565b9050949350505050565b600060408201905061487460008301856142dd565b61488160208301846142dd565b9392505050565b600060608201905061489d60008301866142dd565b6148aa60208301856142dd565b6148b760408301846142dd565b949350505050565b600060a0820190506148d460008301886142dd565b6148e160208301876142dd565b6148ee60408301866142dd565b6148fb60608301856142dd565b6149086080830184613bc0565b9695505050505050565b6000808335600160200384360303811261492b57600080fd5b80840192508235915067ffffffffffffffff82111561494957600080fd5b60208301925060208202360383131561496157600080fd5b509250929050565b6000808335600160200384360303811261498257600080fd5b80840192508235915067ffffffffffffffff8211156149a057600080fd5b6020830192506001820236038313156149b857600080fd5b509250929050565b60008235600160c0038336030381126149d857600080fd5b80830191505092915050565b600082356001610100038336030381126149fd57600080fd5b80830191505092915050565b6000604051905081810181811067ffffffffffffffff82111715614a2c57600080fd5b8060405250919050565b600067ffffffffffffffff821115614a4d57600080fd5b602082029050602081019050919050565b6000819050919050565b6000819050602082019050919050565b600081519050919050565b600081519050919050565b600081519050919050565b6000602082019050919050565b6000602082019050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000614b0060208401846132fe565b905092915050565b6000614b1382614bc1565b9050919050565b6000614b2582614bc1565b9050919050565b60008115159050919050565b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b6000614b6f82614b08565b9050919050565b6000614b8182614b08565b9050919050565b6000614b9382614b08565b9050919050565b600081600f0b9050919050565b60006dffffffffffffffffffffffffffff82169050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600063ffffffff82169050919050565b6000614c0682614c0d565b9050919050565b6000614c1882614c1f565b9050919050565b6000614c2a82614bc1565b9050919050565b82818337600083830152505050565b60005b83811015614c5e578082015181840152602081019050614c43565b83811115614c6d576000848401525b50505050565b6000819050919050565b6000819050919050565b6000601f19601f8301169050919050565b614ca181614b08565b8114614cac57600080fd5b50565b614cb881614b1a565b8114614cc357600080fd5b50565b614ccf81614b2c565b8114614cda57600080fd5b50565b614ce681614b38565b8114614cf157600080fd5b50565b614cfd81614b64565b8114614d0857600080fd5b50565b614d1481614b76565b8114614d1f57600080fd5b50565b614d2b81614b88565b8114614d3657600080fd5b50565b60028110614d4657600080fd5b50565b614d5281614b9a565b8114614d5d57600080fd5b50565b614d6981614ba7565b8114614d7457600080fd5b50565b614d8081614be1565b8114614d8b57600080fd5b50565b614d9781614beb565b8114614da257600080fd5b5056fea2646970667358221220e4cd51d0b236cc2dc9cbb42ec518e9cf563ae695ca5aa9d347c33582355ee26f64736f6c634300060c00330000000000000000000000009fffe8d0336b87b60ac847465be7459c1289df7300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

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