Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function multicall(bytes[] calldata d ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResult(
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function safePermit(
•    - function _callOptionalReturn(IERC20 t ...
• interface IWETH
•    - function deposit()
•    - function withdraw(uint256)
•    - function balanceOf(address)
• interface IWrapToken
•    - function depositFrom(address from, ad ...
•    - function withdraw(address to, uint256 ...
•    - function balanceOf(address)
•  contract SwapProxy is Multicall *
•    - function safeTransferETH(address to, ...
•    - function depositWETH(address weth)
•    - function unwrapWETH(address weth, add ...
•    - function refundETH()
•    - function depositWrapToken(address wra ...
•    - function withdrawWrapToken(address wr ...
•    - function depositToken(address token, ...
•    - function sweepToken(
•    - function approveToken(address token, ...
•    - function proxy(address targetContract ...

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-08-14
*/

// Sources flattened with hardhat v2.12.0 https://hardhat.org

// File contracts/multicall.sol

//  SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.4;

/// @title Multicall
/// @notice Enables calling multiple methods in a single call to the contract
abstract contract Multicall {
    function multicall(bytes[] calldata data) external payable returns (bytes[] memory results) {
        results = new bytes[](data.length);
        for (uint256 i = 0; i < data.length; i++) {
            (bool success, bytes memory result) = address(this).delegatecall(data[i]);

            if (!success) {
                // Next 5 lines from https://ethereum.stackexchange.com/a/83577
                if (result.length < 68) revert();
                assembly {
                    result := add(result, 0x04)
                }
                revert(abi.decode(result, (string)));
            }

            results[i] = result;
        }
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]

// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}


// File @openzeppelin/contracts/utils/[email protected]

// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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");

        (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");

        (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");

        (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.4._
     */
    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.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal 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
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// File @openzeppelin/contracts/token/ERC20/utils/[email protected]

// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;



/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    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'
        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) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

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

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @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
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}


// File contracts/swapProxy/SwapProxy.sol

pragma solidity ^0.8.4;



interface IWETH {
    function deposit() external payable;
    function withdraw(uint256) external;
    function balanceOf(address) external returns (uint256);
}

interface IWrapToken {
    function depositFrom(address from, address to, uint256 amount) external returns(uint256 actualAmount);
    function withdraw(address to, uint256 amount) external returns(uint256 actualAmount);
    function balanceOf(address) external returns (uint256);
}

contract SwapProxy is Multicall {

    using SafeERC20 for IERC20;
    receive() external payable {}

    address public pancakeV3;
    address public pancakeV2;
    address public uniswap;

    constructor(address _pancakeV2, address _pancakeV3, address _uniswap) {
        pancakeV2 = _pancakeV2;
        pancakeV3 = _pancakeV3;
        uniswap = _uniswap;
    }

    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, 'STE');
    }

    function depositWETH(address weth) external payable {
        IWETH(weth).deposit{value: msg.value}();
    }

    function unwrapWETH(address weth, address recipient) external {
        uint256 all = IWETH(weth).balanceOf(address(this));
        IWETH(weth).withdraw(all);
        safeTransferETH(recipient, all);
    }

    function refundETH() external payable {
        if (address(this).balance > 0) safeTransferETH(msg.sender, address(this).balance);
    }

    function depositWrapToken(address wrapToken, uint256 value) external {
        IWrapToken(wrapToken).depositFrom(msg.sender, address(this), value);
    }

    function withdrawWrapToken(address wrapToken, address recipient) external {
        uint256 value = IWrapToken(wrapToken).balanceOf(address(this));
        if (value > 0) {
            IWrapToken(wrapToken).withdraw(recipient, value);
        }
    }

    function depositToken(address token, uint256 value) external {
        IERC20(token).safeTransferFrom(msg.sender, address(this), value);
    }
    
    function sweepToken(
        address token,
        address recipient
    ) external {
        uint256 all = IERC20(token).balanceOf(address(this));
        if (all > 0) {
            IERC20(token).safeTransfer(recipient, all);
        }
    }

    function approveToken(address token, address spender) external {
        bool ok = IERC20(token).approve(spender, type(uint256).max);
        require(ok, 'approve fail');
    }

    function proxy(address targetContract, bytes calldata data, uint256 msgValue) external payable returns (bytes memory res){
        require(targetContract != address(0), "TARGET IS ZERO!");
        require(targetContract == pancakeV2 || targetContract == pancakeV3 || targetContract == uniswap, "TARGET ERROR");
        require(address(this).balance >= msgValue, "ETH NOT ENOUGH!");
        (bool success, bytes memory result) = targetContract.call{value: msgValue}(data);
        
        if (!success) {
            // Next 5 lines from https://ethereum.stackexchange.com/a/83577
            if (result.length < 68) revert();
            assembly {
                result := add(result, 0x04)
            }
            revert(abi.decode(result, (string)));
        }
        return result;
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_pancakeV2","type":"address"},{"internalType":"address","name":"_pancakeV3","type":"address"},{"internalType":"address","name":"_uniswap","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"approveToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"depositToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"weth","type":"address"}],"name":"depositWETH","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"wrapToken","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"depositWrapToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"pancakeV2","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pancakeV3","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"targetContract","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256","name":"msgValue","type":"uint256"}],"name":"proxy","outputs":[{"internalType":"bytes","name":"res","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"refundETH","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"recipient","type":"address"}],"name":"sweepToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswap","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"weth","type":"address"},{"internalType":"address","name":"recipient","type":"address"}],"name":"unwrapWETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"wrapToken","type":"address"},{"internalType":"address","name":"recipient","type":"address"}],"name":"withdrawWrapToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

19829:2886:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21712:179;;;;;;;;;;-1:-1:-1;21712:179:0;;;;;:::i;:::-;;:::i;:::-;;19971:24;;;;;;;;;;-1:-1:-1;19971:24:0;;;;-1:-1:-1;;;;;19971:24:0;;;;;;-1:-1:-1;;;;;4842:55:1;;;4824:74;;4812:2;4797:18;19971:24:0;;;;;;;;20508:209;;;;;;;;;;-1:-1:-1;20508:209:0;;;;;:::i;:::-;;:::i;20725:138::-;;;:::i;21453:251::-;;;;;;;;;;-1:-1:-1;21453:251:0;;;;;:::i;:::-;;:::i;20002:22::-;;;;;;;;;;-1:-1:-1;20002:22:0;;;;-1:-1:-1;;;;;20002:22:0;;;21297:144;;;;;;;;;;-1:-1:-1;21297:144:0;;;;;:::i;:::-;;:::i;19940:24::-;;;;;;;;;;-1:-1:-1;19940:24:0;;;;-1:-1:-1;;;;;19940:24:0;;;20390:110;;;;;;:::i;:::-;;:::i;20871:155::-;;;;;;;;;;-1:-1:-1;20871:155:0;;;;;:::i;:::-;;:::i;301:662::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;21034:255::-;;;;;;;;;;-1:-1:-1;21034:255:0;;;;;:::i;:::-;;:::i;21899:811::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;21712:179::-;21796:49;;;;;-1:-1:-1;;;;;5504:55:1;;;21796:49:0;;;5486:74:1;-1:-1:-1;;5576:18:1;;;5569:34;21786:7:0;;21796:21;;;;;;5459:18:1;;21796:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21786:59;;21864:2;21856:27;;;;-1:-1:-1;;;21856:27:0;;9606:2:1;21856:27:0;;;9588:21:1;9645:2;9625:18;;;9618:30;9684:14;9664:18;;;9657:42;9716:18;;21856:27:0;;;;;;;;;21712:179;;;:::o;20508:209::-;20595:36;;-1:-1:-1;;;20595:36:0;;20625:4;20595:36;;;4824:74:1;20581:11:0;;-1:-1:-1;;;;;20595:21:0;;;;;4797:18:1;;20595:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20642:25;;;;;;;;9891::1;;;20581:50:0;;-1:-1:-1;;;;;;20642:20:0;;;;;9864:18:1;;20642:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20678:31;20694:9;20705:3;20678:15;:31::i;20725:138::-;20778:21;:25;20774:81;;20805:50;20821:10;20833:21;20805:15;:50::i;:::-;20725:138::o;21453:251::-;21566:38;;-1:-1:-1;;;21566:38:0;;21598:4;21566:38;;;4824:74:1;21552:11:0;;-1:-1:-1;;;;;21566:23:0;;;;;4797:18:1;;21566:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21552:52;-1:-1:-1;21619:7:0;;21615:82;;21643:42;-1:-1:-1;;;;;21643:26:0;;21670:9;21681:3;21643:26;:42::i;21297:144::-;21369:64;-1:-1:-1;;;;;21369:30:0;;21400:10;21420:4;21427:5;21369:30;:64::i;:::-;21297:144;;:::o;20390:110::-;20459:4;-1:-1:-1;;;;;20453:19:0;;20480:9;20453:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20390:110;:::o;20871:155::-;20951:67;;;;;20985:10;20951:67;;;5172:34:1;21005:4:0;5222:18:1;;;5215:43;5274:18;;;5267:34;;;-1:-1:-1;;;;;20951:33:0;;;;;5084:18:1;;20951:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;301:662::-;369:22;426:4;414:24;;;;;;-1:-1:-1;;;414:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;404:34;;454:9;449:507;469:15;;;449:507;;;507:12;;552:4;571;;576:1;571:7;;;;;-1:-1:-1;;;571:7:0;;;;;;;;;;;;;;;;;;;;:::i;:::-;544:35;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;506:73;;;;601:7;596:313;;730:2;714:6;:13;:18;710:32;;;734:8;;;710:32;815:4;807:6;803:17;793:27;;875:6;864:28;;;;;;;;;;;;:::i;:::-;857:36;;-1:-1:-1;;;857:36:0;;;;;;;;:::i;596:313::-;938:6;925:7;933:1;925:10;;;;;;-1:-1:-1;;;925:10:0;;;;;;;;;;;;;;:19;;;;449:507;;486:3;;;;;:::i;:::-;;;;449:507;;;;301:662;;;;:::o;21034:255::-;21135:46;;-1:-1:-1;;;21135:46:0;;21175:4;21135:46;;;4824:74:1;21119:13:0;;-1:-1:-1;;;;;21135:31:0;;;;;4797:18:1;;21135:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21119:62;-1:-1:-1;21196:9:0;;21192:90;;21222:48;;;;;-1:-1:-1;;;;;5504:55:1;;;21222:48:0;;;5486:74:1;5576:18;;;5569:34;;;21222:30:0;;;;;5459:18:1;;21222:48:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;21034:255;;;:::o;21899:811::-;22003:16;-1:-1:-1;;;;;22039:28:0;;22031:56;;;;-1:-1:-1;;;22031:56:0;;7742:2:1;22031:56:0;;;7724:21:1;7781:2;7761:18;;;7754:30;7820:17;7800:18;;;7793:45;7855:18;;22031:56:0;7714:165:1;22031:56:0;22124:9;;-1:-1:-1;;;;;22106:27:0;;;22124:9;;22106:27;;:58;;-1:-1:-1;22155:9:0;;-1:-1:-1;;;;;22137:27:0;;;22155:9;;22137:27;22106:58;:87;;;-1:-1:-1;22186:7:0;;-1:-1:-1;;;;;22168:25:0;;;22186:7;;22168:25;22106:87;22098:112;;;;-1:-1:-1;;;22098:112:0;;7401:2:1;22098:112:0;;;7383:21:1;7440:2;7420:18;;;7413:30;7479:14;7459:18;;;7452:42;7511:18;;22098:112:0;7373:162:1;22098:112:0;22254:8;22229:21;:33;;22221:61;;;;-1:-1:-1;;;22221:61:0;;8493:2:1;22221:61:0;;;8475:21:1;8532:2;8512:18;;;8505:30;8571:17;8551:18;;;8544:45;8606:18;;22221:61:0;8465:165:1;22221:61:0;22294:12;22308:19;22331:14;-1:-1:-1;;;;;22331:19:0;22358:8;22368:4;;22331:42;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22293:80;;;;22399:7;22394:285;;22520:2;22504:6;:13;:18;22500:32;;;22524:8;;;22394:285;22696:6;21899:811;-1:-1:-1;;;;;;21899:811:0:o;20214:168::-;20327:12;;;20287;20327;;;;;;;;;-1:-1:-1;;;;;20305:7:0;;;20320:5;;20305:35;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20286:54;;;20359:7;20351:23;;;;-1:-1:-1;;;20351:23:0;;7070:2:1;20351:23:0;;;7052:21:1;7109:1;7089:18;;;7082:29;7147:5;7127:18;;;7120:33;7170:18;;20351:23:0;7042:152:1;15503:211:0;15647:58;;-1:-1:-1;;;;;5504:55:1;;15647:58:0;;;5486:74:1;5576:18;;;5569:34;;;15620:86:0;;15640:5;;15670:23;;5459:18:1;;15647:58:0;;;;-1:-1:-1;;15647:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;15620:19;:86::i;15722:248::-;15893:68;;-1:-1:-1;;;;;5190:15:1;;;15893:68:0;;;5172:34:1;5242:15;;5222:18;;;5215:43;5274:18;;;5267:34;;;15866:96:0;;15886:5;;15916:27;;5084:18:1;;15893:68:0;5066:241:1;18570:716:0;18994:23;19020:69;19048:4;19020:69;;;;;;;;;;;;;;;;;19028:5;-1:-1:-1;;;;;19020:27:0;;;:69;;;;;:::i;:::-;19104:17;;18994:95;;-1:-1:-1;19104:21:0;19100:179;;19201:10;19190:30;;;;;;;;;;;;:::i;:::-;19182:85;;;;-1:-1:-1;;;19182:85:0;;9195:2:1;19182:85:0;;;9177:21:1;9234:2;9214:18;;;9207:30;9273:34;9253:18;;;9246:62;9344:12;9324:18;;;9317:40;9374:19;;19182:85:0;9167:232:1;10210:229:0;10347:12;10379:52;10401:6;10409:4;10415:1;10418:12;10379:21;:52::i;:::-;10372:59;;10210:229;;;;;;:::o;11330:510::-;11500:12;11558:5;11533:21;:30;;11525:81;;;;-1:-1:-1;;;11525:81:0;;8086:2:1;11525:81:0;;;8068:21:1;8125:2;8105:18;;;8098:30;8164:34;8144:18;;;8137:62;8235:8;8215:18;;;8208:36;8261:19;;11525:81:0;8058:228:1;11525:81:0;-1:-1:-1;;;;;7760:19:0;;;11617:60;;;;-1:-1:-1;;;11617:60:0;;8837:2:1;11617:60:0;;;8819:21:1;8876:2;8856:18;;;8849:30;8915:31;8895:18;;;8888:59;8964:18;;11617:60:0;8809:179:1;11617:60:0;11691:12;11705:23;11732:6;-1:-1:-1;;;;;11732:11:0;11751:5;11758:4;11732:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11690:73;;;;11781:51;11798:7;11807:10;11819:12;11781:16;:51::i;:::-;11774:58;11330:510;-1:-1:-1;;;;;;;11330:510:0:o;14016:762::-;14166:12;14195:7;14191:580;;;-1:-1:-1;14226:10:0;14219:17;;14191:580;14340:17;;:21;14336:424;;14588:10;14582:17;14649:15;14636:10;14632:2;14628:19;14621:44;14536:148;14731:12;14724:20;;-1:-1:-1;;;14724:20:0;;;;;;;;:::i;14:196:1:-;82:20;;-1:-1:-1;;;;;131:54:1;;121:65;;111:2;;200:1;197;190:12;111:2;63:147;;;:::o;215:196::-;274:6;327:2;315:9;306:7;302:23;298:32;295:2;;;348:6;340;333:22;295:2;376:29;395:9;376:29;:::i;416:270::-;484:6;492;545:2;533:9;524:7;520:23;516:32;513:2;;;566:6;558;551:22;513:2;594:29;613:9;594:29;:::i;:::-;584:39;;642:38;676:2;665:9;661:18;642:38;:::i;:::-;632:48;;503:183;;;;;:::o;691:783::-;779:6;787;795;803;856:2;844:9;835:7;831:23;827:32;824:2;;;877:6;869;862:22;824:2;905:29;924:9;905:29;:::i;:::-;895:39;;985:2;974:9;970:18;957:32;1008:18;1049:2;1041:6;1038:14;1035:2;;;1070:6;1062;1055:22;1035:2;1113:6;1102:9;1098:22;1088:32;;1158:7;1151:4;1147:2;1143:13;1139:27;1129:2;;1185:6;1177;1170:22;1129:2;1230;1217:16;1256:2;1248:6;1245:14;1242:2;;;1277:6;1269;1262:22;1242:2;1327:7;1322:2;1313:6;1309:2;1305:15;1301:24;1298:37;1295:2;;;1353:6;1345;1338:22;1295:2;814:660;;1389:2;1381:11;;;;;-1:-1:-1;1411:6:1;;1464:2;1449:18;1436:32;;-1:-1:-1;814:660:1;-1:-1:-1;;;814:660:1:o;1479:264::-;1547:6;1555;1608:2;1596:9;1587:7;1583:23;1579:32;1576:2;;;1629:6;1621;1614:22;1576:2;1657:29;1676:9;1657:29;:::i;:::-;1647:39;1733:2;1718:18;;;;1705:32;;-1:-1:-1;;;1566:177:1:o;1748:676::-;1845:6;1853;1906:2;1894:9;1885:7;1881:23;1877:32;1874:2;;;1927:6;1919;1912:22;1874:2;1972:9;1959:23;2001:18;2042:2;2034:6;2031:14;2028:2;;;2063:6;2055;2048:22;2028:2;2106:6;2095:9;2091:22;2081:32;;2151:7;2144:4;2140:2;2136:13;2132:27;2122:2;;2178:6;2170;2163:22;2122:2;2223;2210:16;2249:2;2241:6;2238:14;2235:2;;;2270:6;2262;2255:22;2235:2;2328:7;2323:2;2313:6;2310:1;2306:14;2302:2;2298:23;2294:32;2291:45;2288:2;;;2354:6;2346;2339:22;2288:2;2390;2382:11;;;;;2412:6;;-1:-1:-1;1864:560:1;;-1:-1:-1;;;;1864:560:1:o;2429:297::-;2496:6;2549:2;2537:9;2528:7;2524:23;2520:32;2517:2;;;2570:6;2562;2555:22;2517:2;2607:9;2601:16;2660:5;2653:13;2646:21;2639:5;2636:32;2626:2;;2687:6;2679;2672:22;2731:924;2811:6;2864:2;2852:9;2843:7;2839:23;2835:32;2832:2;;;2885:6;2877;2870:22;2832:2;2923:9;2917:16;2952:18;2993:2;2985:6;2982:14;2979:2;;;3014:6;3006;2999:22;2979:2;3057:6;3046:9;3042:22;3032:32;;3102:7;3095:4;3091:2;3087:13;3083:27;3073:2;;3129:6;3121;3114:22;3073:2;3163;3157:9;3185:2;3181;3178:10;3175:2;;;3191:18;;:::i;:::-;3266:2;3260:9;3234:2;3320:13;;-1:-1:-1;;3316:22:1;;;3340:2;3312:31;3308:40;3296:53;;;3364:18;;;3384:22;;;3361:46;3358:2;;;3410:18;;:::i;:::-;3450:10;3446:2;3439:22;3485:2;3477:6;3470:18;3525:7;3520:2;3515;3511;3507:11;3503:20;3500:33;3497:2;;;3551:6;3543;3536:22;3497:2;3569:55;3621:2;3616;3608:6;3604:15;3599:2;3595;3591:11;3569:55;:::i;3660:194::-;3730:6;3783:2;3771:9;3762:7;3758:23;3754:32;3751:2;;;3804:6;3796;3789:22;3751:2;-1:-1:-1;3832:16:1;;3741:113;-1:-1:-1;3741:113:1:o;3859:257::-;3900:3;3938:5;3932:12;3965:6;3960:3;3953:19;3981:63;4037:6;4030:4;4025:3;4021:14;4014:4;4007:5;4003:16;3981:63;:::i;:::-;4098:2;4077:15;-1:-1:-1;;4073:29:1;4064:39;;;;4105:4;4060:50;;3908:208;-1:-1:-1;;3908:208:1:o;4121:273::-;4304:6;4296;4291:3;4278:33;4260:3;4330:16;;4355:15;;;4330:16;4268:126;-1:-1:-1;4268:126:1:o;4399:274::-;4528:3;4566:6;4560:13;4582:53;4628:6;4623:3;4616:4;4608:6;4604:17;4582:53;:::i;:::-;4651:16;;;;;4536:137;-1:-1:-1;;4536:137:1:o;5614:803::-;5774:4;5803:2;5843;5832:9;5828:18;5873:2;5862:9;5855:21;5896:6;5931;5925:13;5962:6;5954;5947:22;6000:2;5989:9;5985:18;5978:25;;6062:2;6052:6;6049:1;6045:14;6034:9;6030:30;6026:39;6012:53;;6100:2;6092:6;6088:15;6121:4;6134:254;6148:6;6145:1;6142:13;6134:254;;;6241:2;6237:7;6225:9;6217:6;6213:22;6209:36;6204:3;6197:49;6269:39;6301:6;6292;6286:13;6269:39;:::i;:::-;6259:49;-1:-1:-1;6366:12:1;;;;6331:15;;;;6170:1;6163:9;6134:254;;;-1:-1:-1;6405:6:1;;5783:634;-1:-1:-1;;;;;;;5783:634:1:o;6422:217::-;6569:2;6558:9;6551:21;6532:4;6589:44;6629:2;6618:9;6614:18;6606:6;6589:44;:::i;9927:533::-;10004:4;10010:6;10070:11;10057:25;10164:2;10160:7;10149:8;10133:14;10129:29;10125:43;10105:18;10101:68;10091:2;;10186:4;10180;10173:18;10091:2;10216:33;;10268:20;;;-1:-1:-1;10311:18:1;10300:30;;10297:2;;;10346:4;10340;10333:18;10297:2;10382:4;10370:17;;-1:-1:-1;10413:14:1;10409:27;;;10399:38;;10396:2;;;10450:1;10447;10440:12;10396:2;10021:439;;;;;:::o;10465:258::-;10537:1;10547:113;10561:6;10558:1;10555:13;10547:113;;;10637:11;;;10631:18;10618:11;;;10611:39;10583:2;10576:10;10547:113;;;10678:6;10675:1;10672:13;10669:2;;;-1:-1:-1;;10713:1:1;10695:16;;10688:27;10518:205::o;10728:293::-;10767:3;-1:-1:-1;;10788:17:1;;10785:2;;;-1:-1:-1;;;10835:3:1;10828:90;10941:4;10938:1;10931:15;10971:4;10966:3;10959:17;10785:2;-1:-1:-1;11013:1:1;11002:13;;10775:246::o;11026:184::-;-1:-1:-1;;;11075:1:1;11068:88;11175:4;11172:1;11165:15;11199:4;11196:1;11189:15

ipfs://97abada1ec40d3bc939d6589e61b526fca48d1d4517b5a0bdd6a208f6bcdf7a2