Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

•  contract FeeSender *
•    - function withdraw(address[] calldata ...
• library Address
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(bool succes ...
•    - function _revert(bytes memory returnd ...
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• 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(address from, a ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function forceApprove(IERC20 token, a ...
•    - function _callOptionalReturn(IERC20 t ...
•    - function _callOptionalReturnBool(IERC ...

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at ftmscan.com on 2024-06-04
*/

//SPDX-License-Identifier: GPL

// File: contracts/FeeSender.sol
pragma solidity ^0.8.0;



contract FeeSender {
    using SafeERC20 for IERC20;

    address public constant receiver40 = 0xf4475aC4B4a07b701C790d068a06eE6B33533218;
    address public constant receiver60 = 0x35099FB9446CFa57259948411C54d33A96C7Dd3d;

    function withdraw(address[] calldata tokens, bool withdrawGasToken) external {
        IERC20 token;
        
        if(withdrawGasToken) {
            (bool sent, bytes memory data) = receiver60.call{value: address(this).balance * 6000 / 10000}("");
            require(sent, "Failed to send Ether");
            (sent, data) = receiver40.call{value: address(this).balance}("");
            require(sent, "Failed to send Ether");
        }
        
        for(uint i = 0; i < tokens.length; i++) {
            token = IERC20(tokens[i]);
            
            token.transfer(receiver60, token.balanceOf(address(this)) * 6000 / 10000);
            token.transfer(receiver40, token.balanceOf(address(this)));
        }
    }
    
    receive() external payable {}
} 


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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @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://consensys.net/diligence/blog/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.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // 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 FailedInnerCall();
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @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.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
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].
     *
     * CAUTION: See Security Considerations above.
     */
    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/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;




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

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @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);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @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).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // 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 cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"receiver40","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"receiver60","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"bool","name":"withdrawGasToken","type":"bool"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

99:1022:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;246:79;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;334:743;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;160:79;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;246;283:42;246:79;:::o;334:743::-;422:12;458:16;455:328;;;492:9;503:17;283:42;524:15;;578:5;571:4;547:21;:28;;;;:::i;:::-;:36;;;;:::i;:::-;524:64;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;491:97;;;;611:4;603:37;;;;;;;;;;;;:::i;:::-;;;;;;;;;197:42;670:15;;693:21;670:49;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;655:64;;;;;;;;742:4;734:37;;;;;;;;;;;;:::i;:::-;;;;;;;;;476:307;;455:328;807:6;803:267;823:6;;:13;;819:1;:17;803:267;;;873:6;;880:1;873:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;858:25;;912:5;:14;;;283:42;979:5;972:4;939:5;:15;;;963:4;939:30;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:37;;;;:::i;:::-;:45;;;;:::i;:::-;912:73;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;1000:5;:14;;;197:42;1027:5;:15;;;1051:4;1027:30;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1000:58;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;838:3;;;;;;;803:267;;;;411:666;334:743;;;:::o;160:79::-;197:42;160:79;:::o;7:126:1:-;44:7;84:42;77:5;73:54;62:65;;7:126;;;:::o;139:96::-;176:7;205:24;223:5;205:24;:::i;:::-;194:35;;139:96;;;:::o;241:118::-;328:24;346:5;328:24;:::i;:::-;323:3;316:37;241:118;;:::o;365:222::-;458:4;496:2;485:9;481:18;473:26;;509:71;577:1;566:9;562:17;553:6;509:71;:::i;:::-;365:222;;;;:::o;674:117::-;783:1;780;773:12;797:117;906:1;903;896:12;920:117;1029:1;1026;1019:12;1043:117;1152:1;1149;1142:12;1166:117;1275:1;1272;1265:12;1306:568;1379:8;1389:6;1439:3;1432:4;1424:6;1420:17;1416:27;1406:122;;1447:79;;:::i;:::-;1406:122;1560:6;1547:20;1537:30;;1590:18;1582:6;1579:30;1576:117;;;1612:79;;:::i;:::-;1576:117;1726:4;1718:6;1714:17;1702:29;;1780:3;1772:4;1764:6;1760:17;1750:8;1746:32;1743:41;1740:128;;;1787:79;;:::i;:::-;1740:128;1306:568;;;;;:::o;1880:90::-;1914:7;1957:5;1950:13;1943:21;1932:32;;1880:90;;;:::o;1976:116::-;2046:21;2061:5;2046:21;:::i;:::-;2039:5;2036:32;2026:60;;2082:1;2079;2072:12;2026:60;1976:116;:::o;2098:133::-;2141:5;2179:6;2166:20;2157:29;;2195:30;2219:5;2195:30;:::i;:::-;2098:133;;;;:::o;2237:698::-;2329:6;2337;2345;2394:2;2382:9;2373:7;2369:23;2365:32;2362:119;;;2400:79;;:::i;:::-;2362:119;2548:1;2537:9;2533:17;2520:31;2578:18;2570:6;2567:30;2564:117;;;2600:79;;:::i;:::-;2564:117;2713:80;2785:7;2776:6;2765:9;2761:22;2713:80;:::i;:::-;2695:98;;;;2491:312;2842:2;2868:50;2910:7;2901:6;2890:9;2886:22;2868:50;:::i;:::-;2858:60;;2813:115;2237:698;;;;;:::o;2941:77::-;2978:7;3007:5;2996:16;;2941:77;;;:::o;3024:180::-;3072:77;3069:1;3062:88;3169:4;3166:1;3159:15;3193:4;3190:1;3183:15;3210:410;3250:7;3273:20;3291:1;3273:20;:::i;:::-;3268:25;;3307:20;3325:1;3307:20;:::i;:::-;3302:25;;3362:1;3359;3355:9;3384:30;3402:11;3384:30;:::i;:::-;3373:41;;3563:1;3554:7;3550:15;3547:1;3544:22;3524:1;3517:9;3497:83;3474:139;;3593:18;;:::i;:::-;3474:139;3258:362;3210:410;;;;:::o;3626:180::-;3674:77;3671:1;3664:88;3771:4;3768:1;3761:15;3795:4;3792:1;3785:15;3812:185;3852:1;3869:20;3887:1;3869:20;:::i;:::-;3864:25;;3903:20;3921:1;3903:20;:::i;:::-;3898:25;;3942:1;3932:35;;3947:18;;:::i;:::-;3932:35;3989:1;3986;3982:9;3977:14;;3812:185;;;;:::o;4003:147::-;4104:11;4141:3;4126:18;;4003:147;;;;:::o;4156:114::-;;:::o;4276:398::-;4435:3;4456:83;4537:1;4532:3;4456:83;:::i;:::-;4449:90;;4548:93;4637:3;4548:93;:::i;:::-;4666:1;4661:3;4657:11;4650:18;;4276:398;;;:::o;4680:379::-;4864:3;4886:147;5029:3;4886:147;:::i;:::-;4879:154;;5050:3;5043:10;;4680:379;;;:::o;5065:169::-;5149:11;5183:6;5178:3;5171:19;5223:4;5218:3;5214:14;5199:29;;5065:169;;;;:::o;5240:170::-;5380:22;5376:1;5368:6;5364:14;5357:46;5240:170;:::o;5416:366::-;5558:3;5579:67;5643:2;5638:3;5579:67;:::i;:::-;5572:74;;5655:93;5744:3;5655:93;:::i;:::-;5773:2;5768:3;5764:12;5757:19;;5416:366;;;:::o;5788:419::-;5954:4;5992:2;5981:9;5977:18;5969:26;;6041:9;6035:4;6031:20;6027:1;6016:9;6012:17;6005:47;6069:131;6195:4;6069:131;:::i;:::-;6061:139;;5788:419;;;:::o;6213:180::-;6261:77;6258:1;6251:88;6358:4;6355:1;6348:15;6382:4;6379:1;6372:15;6399:122;6472:24;6490:5;6472:24;:::i;:::-;6465:5;6462:35;6452:63;;6511:1;6508;6501:12;6452:63;6399:122;:::o;6527:139::-;6573:5;6611:6;6598:20;6589:29;;6627:33;6654:5;6627:33;:::i;:::-;6527:139;;;;:::o;6672:329::-;6731:6;6780:2;6768:9;6759:7;6755:23;6751:32;6748:119;;;6786:79;;:::i;:::-;6748:119;6906:1;6931:53;6976:7;6967:6;6956:9;6952:22;6931:53;:::i;:::-;6921:63;;6877:117;6672:329;;;;:::o;7007:122::-;7080:24;7098:5;7080:24;:::i;:::-;7073:5;7070:35;7060:63;;7119:1;7116;7109:12;7060:63;7007:122;:::o;7135:143::-;7192:5;7223:6;7217:13;7208:22;;7239:33;7266:5;7239:33;:::i;:::-;7135:143;;;;:::o;7284:351::-;7354:6;7403:2;7391:9;7382:7;7378:23;7374:32;7371:119;;;7409:79;;:::i;:::-;7371:119;7529:1;7554:64;7610:7;7601:6;7590:9;7586:22;7554:64;:::i;:::-;7544:74;;7500:128;7284:351;;;;:::o;7641:118::-;7728:24;7746:5;7728:24;:::i;:::-;7723:3;7716:37;7641:118;;:::o;7765:332::-;7886:4;7924:2;7913:9;7909:18;7901:26;;7937:71;8005:1;7994:9;7990:17;7981:6;7937:71;:::i;:::-;8018:72;8086:2;8075:9;8071:18;8062:6;8018:72;:::i;:::-;7765:332;;;;;:::o;8103:137::-;8157:5;8188:6;8182:13;8173:22;;8204:30;8228:5;8204:30;:::i;:::-;8103:137;;;;:::o;8246:345::-;8313:6;8362:2;8350:9;8341:7;8337:23;8333:32;8330:119;;;8368:79;;:::i;:::-;8330:119;8488:1;8513:61;8566:7;8557:6;8546:9;8542:22;8513:61;:::i;:::-;8503:71;;8459:125;8246:345;;;;:::o

ipfs://e57347bce3df31bddce10e22b200b188327973f10afd718697735d72104a7668