Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• 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 ...
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• 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 ...
• 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 ...
•  contract SuperStaking *
•    - function setToken(address _token)
•    - function withdrawTokens()
•    - function getContractBalance()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-08-21
*/

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

// File: SuperStaking6.sol


pragma solidity ^0.8.25;



contract SuperStaking {
    using SafeERC20 for IERC20;

    IERC20 public token;
    address public owner;
    uint256 public totalDeposited;

    event TokensWithdrawn(address indexed owner, uint256 amount);
    event TokensReceived(address indexed from, uint256 amount);

    modifier onlyOwner() {
        require(msg.sender == owner, "Not the owner");
        _;
    }

    constructor() {
        owner = msg.sender;
    }

    // Allows the owner to set the ERC20 token.
    function setToken(address _token) external onlyOwner {
        require(address(token) == address(0), "Token already set");
        token = IERC20(_token);
    }

    // Allows the owner to withdraw all tokens from the contract.
    function withdrawTokens() external onlyOwner {
        uint256 contractBalance = token.balanceOf(address(this));
        require(contractBalance > 0, "No tokens to withdraw");

        token.safeTransfer(owner, contractBalance);
        emit TokensWithdrawn(owner, contractBalance);
    }

    // Returns the balance of tokens in the contract.
    function getContractBalance() external view returns (uint256) {
        return token.balanceOf(address(this));
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensWithdrawn","type":"event"},{"inputs":[],"name":"getContractBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"setToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDeposited","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x608060405234801561000f575f80fd5b5060043610610060575f3560e01c8063144fa6d7146100645780636f9fb98a146100805780638d8f2adb1461009e5780638da5cb5b146100a8578063fc0c546a146100c6578063ff50abdc146100e4575b5f80fd5b61007e600480360381019061007991906108b6565b610102565b005b610088610260565b60405161009591906108f9565b60405180910390f35b6100a66102fe565b005b6100b0610547565b6040516100bd9190610921565b60405180910390f35b6100ce61056c565b6040516100db9190610995565b60405180910390f35b6100ec61058f565b6040516100f991906108f9565b60405180910390f35b60015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610191576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161018890610a08565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff165f8054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff161461021e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161021590610a70565b60405180910390fd5b805f806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b5f805f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016102ba9190610921565b602060405180830381865afa1580156102d5573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102f99190610ab8565b905090565b60015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461038d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161038490610a08565b60405180910390fd5b5f805f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016103e79190610921565b602060405180830381865afa158015610402573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906104269190610ab8565b90505f811161046a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161046190610b2d565b60405180910390fd5b6104d560015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16825f8054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166105959092919063ffffffff16565b60015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f6352c5382c4a4578e712449ca65e83cdb392d045dfcf1cad9615189db2da244b8260405161053c91906108f9565b60405180910390a250565b60015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f8054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60025481565b61060f838473ffffffffffffffffffffffffffffffffffffffff1663a9059cbb85856040516024016105c8929190610b4b565b604051602081830303815290604052915060e01b6020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050610614565b505050565b5f61063e828473ffffffffffffffffffffffffffffffffffffffff166106a990919063ffffffff16565b90505f8151141580156106625750808060200190518101906106609190610ba7565b155b156106a457826040517f5274afe700000000000000000000000000000000000000000000000000000000815260040161069b9190610921565b60405180910390fd5b505050565b60606106b683835f6106be565b905092915050565b60608147101561070557306040517fcd7860590000000000000000000000000000000000000000000000000000000081526004016106fc9190610921565b60405180910390fd5b5f808573ffffffffffffffffffffffffffffffffffffffff16848660405161072d9190610c24565b5f6040518083038185875af1925050503d805f8114610767576040519150601f19603f3d011682016040523d82523d5f602084013e61076c565b606091505b509150915061077c868383610787565b925050509392505050565b60608261079c5761079782610814565b61080c565b5f82511480156107c257505f8473ffffffffffffffffffffffffffffffffffffffff163b145b1561080457836040517f9996b3150000000000000000000000000000000000000000000000000000000081526004016107fb9190610921565b60405180910390fd5b81905061080d565b5b9392505050565b5f815111156108265780518082602001fd5b6040517f1425ea4200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f80fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6108858261085c565b9050919050565b6108958161087b565b811461089f575f80fd5b50565b5f813590506108b08161088c565b92915050565b5f602082840312156108cb576108ca610858565b5b5f6108d8848285016108a2565b91505092915050565b5f819050919050565b6108f3816108e1565b82525050565b5f60208201905061090c5f8301846108ea565b92915050565b61091b8161087b565b82525050565b5f6020820190506109345f830184610912565b92915050565b5f819050919050565b5f61095d6109586109538461085c565b61093a565b61085c565b9050919050565b5f61096e82610943565b9050919050565b5f61097f82610964565b9050919050565b61098f81610975565b82525050565b5f6020820190506109a85f830184610986565b92915050565b5f82825260208201905092915050565b7f4e6f7420746865206f776e6572000000000000000000000000000000000000005f82015250565b5f6109f2600d836109ae565b91506109fd826109be565b602082019050919050565b5f6020820190508181035f830152610a1f816109e6565b9050919050565b7f546f6b656e20616c7265616479207365740000000000000000000000000000005f82015250565b5f610a5a6011836109ae565b9150610a6582610a26565b602082019050919050565b5f6020820190508181035f830152610a8781610a4e565b9050919050565b610a97816108e1565b8114610aa1575f80fd5b50565b5f81519050610ab281610a8e565b92915050565b5f60208284031215610acd57610acc610858565b5b5f610ada84828501610aa4565b91505092915050565b7f4e6f20746f6b656e7320746f20776974686472617700000000000000000000005f82015250565b5f610b176015836109ae565b9150610b2282610ae3565b602082019050919050565b5f6020820190508181035f830152610b4481610b0b565b9050919050565b5f604082019050610b5e5f830185610912565b610b6b60208301846108ea565b9392505050565b5f8115159050919050565b610b8681610b72565b8114610b90575f80fd5b50565b5f81519050610ba181610b7d565b92915050565b5f60208284031215610bbc57610bbb610858565b5b5f610bc984828501610b93565b91505092915050565b5f81519050919050565b5f81905092915050565b8281835e5f83830152505050565b5f610bfe82610bd2565b610c088185610bdc565b9350610c18818560208601610be6565b80840191505092915050565b5f610c2f8284610bf4565b91508190509291505056fea26469706673582212207df8bcf4b4e68e09352c5809be3dc4cb9fcc6b1b6df05e3aaa3124d185489fe364736f6c63430008190033

19115:1218:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19617:163;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;20212:118;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19855:294;;;:::i;:::-;;19205:20;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19179:19;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19232:29;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19617:163;19458:5;;;;;;;;;;;19444:19;;:10;:19;;;19436:45;;;;;;;;;;;;:::i;:::-;;;;;;;;;19715:1:::1;19689:28;;19697:5;::::0;::::1;;;;;;;;19689:28;;;19681:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;19765:6;19750:5;::::0;:22:::1;;;;;;;;;;;;;;;;;;19617:163:::0;:::o;20212:118::-;20265:7;20292:5;;;;;;;;;;;:15;;;20316:4;20292:30;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20285:37;;20212:118;:::o;19855:294::-;19458:5;;;;;;;;;;;19444:19;;:10;:19;;;19436:45;;;;;;;;;;;;:::i;:::-;;;;;;;;;19911:23:::1;19937:5:::0;::::1;;;;;;;;;;:15;;;19961:4;19937:30;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;19911:56;;20004:1;19986:15;:19;19978:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;20044:42;20063:5;;;;;;;;;;;20070:15;20044:5;::::0;::::1;;;;;;;;:18;;;;:42;;;;;:::i;:::-;20118:5;;;;;;;;;;;20102:39;;;20125:15;20102:39;;;;;;:::i;:::-;;;;;;;;19900:249;19855:294::o:0;19205:20::-;;;;;;;;;;;;;:::o;19179:19::-;;;;;;;;;;;;:::o;19232:29::-;;;;:::o;14499:162::-;14582:71;14602:5;14624;:14;;;14641:2;14645:5;14609:43;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14582:19;:71::i;:::-;14499:162;;;:::o;17310:638::-;17734:23;17760:33;17788:4;17768:5;17760:27;;;;:33;;;;:::i;:::-;17734:59;;17829:1;17808:10;:17;:22;;:57;;;;;17846:10;17835:30;;;;;;;;;;;;:::i;:::-;17834:31;17808:57;17804:137;;;17922:5;17889:40;;;;;;;;;;;:::i;:::-;;;;;;;;17804:137;17380:568;17310:638;;:::o;9625:153::-;9700:12;9732:38;9754:6;9762:4;9768:1;9732:21;:38::i;:::-;9725:45;;9625:153;;;;:::o;10113:398::-;10212:12;10265:5;10241:21;:29;10237:110;;;10329:4;10294:41;;;;;;;;;;;:::i;:::-;;;;;;;;10237:110;10358:12;10372:23;10399:6;:11;;10418:5;10425:4;10399:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10357:73;;;;10448:55;10475:6;10483:7;10492:10;10448:26;:55::i;:::-;10441:62;;;;10113:398;;;;;:::o;11589:597::-;11737:12;11767:7;11762:417;;11791:19;11799:10;11791:7;:19::i;:::-;11762:417;;;12040:1;12019:10;:17;:22;:49;;;;;12067:1;12045:6;:18;;;:23;12019:49;12015:121;;;12113:6;12096:24;;;;;;;;;;;:::i;:::-;;;;;;;;12015:121;12157:10;12150:17;;;;11762:417;11589:597;;;;;;:::o;12739:528::-;12892:1;12872:10;:17;:21;12868:392;;;13104:10;13098:17;13161:15;13148:10;13144:2;13140:19;13133:44;12868:392;13231:17;;;;;;;;;;;;;;88:117:1;197:1;194;187:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:329::-;900:6;949:2;937:9;928:7;924:23;920:32;917:119;;;955:79;;:::i;:::-;917:119;1075:1;1100:53;1145:7;1136:6;1125:9;1121:22;1100:53;:::i;:::-;1090:63;;1046:117;841:329;;;;:::o;1176:77::-;1213:7;1242:5;1231:16;;1176:77;;;:::o;1259:118::-;1346:24;1364:5;1346:24;:::i;:::-;1341:3;1334:37;1259:118;;:::o;1383:222::-;1476:4;1514:2;1503:9;1499:18;1491:26;;1527:71;1595:1;1584:9;1580:17;1571:6;1527:71;:::i;:::-;1383:222;;;;:::o;1611:118::-;1698:24;1716:5;1698:24;:::i;:::-;1693:3;1686:37;1611:118;;:::o;1735:222::-;1828:4;1866:2;1855:9;1851:18;1843:26;;1879:71;1947:1;1936:9;1932:17;1923:6;1879:71;:::i;:::-;1735:222;;;;:::o;1963:60::-;1991:3;2012:5;2005:12;;1963:60;;;:::o;2029:142::-;2079:9;2112:53;2130:34;2139:24;2157:5;2139:24;:::i;:::-;2130:34;:::i;:::-;2112:53;:::i;:::-;2099:66;;2029:142;;;:::o;2177:126::-;2227:9;2260:37;2291:5;2260:37;:::i;:::-;2247:50;;2177:126;;;:::o;2309:139::-;2372:9;2405:37;2436:5;2405:37;:::i;:::-;2392:50;;2309:139;;;:::o;2454:157::-;2554:50;2598:5;2554:50;:::i;:::-;2549:3;2542:63;2454:157;;:::o;2617:248::-;2723:4;2761:2;2750:9;2746:18;2738:26;;2774:84;2855:1;2844:9;2840:17;2831:6;2774:84;:::i;:::-;2617:248;;;;:::o;2871:169::-;2955:11;2989:6;2984:3;2977:19;3029:4;3024:3;3020:14;3005:29;;2871:169;;;;:::o;3046:163::-;3186:15;3182:1;3174:6;3170:14;3163:39;3046:163;:::o;3215:366::-;3357:3;3378:67;3442:2;3437:3;3378:67;:::i;:::-;3371:74;;3454:93;3543:3;3454:93;:::i;:::-;3572:2;3567:3;3563:12;3556:19;;3215:366;;;:::o;3587:419::-;3753:4;3791:2;3780:9;3776:18;3768:26;;3840:9;3834:4;3830:20;3826:1;3815:9;3811:17;3804:47;3868:131;3994:4;3868:131;:::i;:::-;3860:139;;3587:419;;;:::o;4012:167::-;4152:19;4148:1;4140:6;4136:14;4129:43;4012:167;:::o;4185:366::-;4327:3;4348:67;4412:2;4407:3;4348:67;:::i;:::-;4341:74;;4424:93;4513:3;4424:93;:::i;:::-;4542:2;4537:3;4533:12;4526:19;;4185:366;;;:::o;4557:419::-;4723:4;4761:2;4750:9;4746:18;4738:26;;4810:9;4804:4;4800:20;4796:1;4785:9;4781:17;4774:47;4838:131;4964:4;4838:131;:::i;:::-;4830:139;;4557:419;;;:::o;4982:122::-;5055:24;5073:5;5055:24;:::i;:::-;5048:5;5045:35;5035:63;;5094:1;5091;5084:12;5035:63;4982:122;:::o;5110:143::-;5167:5;5198:6;5192:13;5183:22;;5214:33;5241:5;5214:33;:::i;:::-;5110:143;;;;:::o;5259:351::-;5329:6;5378:2;5366:9;5357:7;5353:23;5349:32;5346:119;;;5384:79;;:::i;:::-;5346:119;5504:1;5529:64;5585:7;5576:6;5565:9;5561:22;5529:64;:::i;:::-;5519:74;;5475:128;5259:351;;;;:::o;5616:171::-;5756:23;5752:1;5744:6;5740:14;5733:47;5616:171;:::o;5793:366::-;5935:3;5956:67;6020:2;6015:3;5956:67;:::i;:::-;5949:74;;6032:93;6121:3;6032:93;:::i;:::-;6150:2;6145:3;6141:12;6134:19;;5793:366;;;:::o;6165:419::-;6331:4;6369:2;6358:9;6354:18;6346:26;;6418:9;6412:4;6408:20;6404:1;6393:9;6389:17;6382:47;6446:131;6572:4;6446:131;:::i;:::-;6438:139;;6165:419;;;:::o;6590:332::-;6711:4;6749:2;6738:9;6734:18;6726:26;;6762:71;6830:1;6819:9;6815:17;6806:6;6762:71;:::i;:::-;6843:72;6911:2;6900:9;6896:18;6887:6;6843:72;:::i;:::-;6590:332;;;;;:::o;6928:90::-;6962:7;7005:5;6998:13;6991:21;6980:32;;6928:90;;;:::o;7024:116::-;7094:21;7109:5;7094:21;:::i;:::-;7087:5;7084:32;7074:60;;7130:1;7127;7120:12;7074:60;7024:116;:::o;7146:137::-;7200:5;7231:6;7225:13;7216:22;;7247:30;7271:5;7247:30;:::i;:::-;7146:137;;;;:::o;7289:345::-;7356:6;7405:2;7393:9;7384:7;7380:23;7376:32;7373:119;;;7411:79;;:::i;:::-;7373:119;7531:1;7556:61;7609:7;7600:6;7589:9;7585:22;7556:61;:::i;:::-;7546:71;;7502:125;7289:345;;;;:::o;7640:98::-;7691:6;7725:5;7719:12;7709:22;;7640:98;;;:::o;7744:147::-;7845:11;7882:3;7867:18;;7744:147;;;;:::o;7897:139::-;7986:6;7981:3;7976;7970:23;8027:1;8018:6;8013:3;8009:16;8002:27;7897:139;;;:::o;8042:386::-;8146:3;8174:38;8206:5;8174:38;:::i;:::-;8228:88;8309:6;8304:3;8228:88;:::i;:::-;8221:95;;8325:65;8383:6;8378:3;8371:4;8364:5;8360:16;8325:65;:::i;:::-;8415:6;8410:3;8406:16;8399:23;;8150:278;8042:386;;;;:::o;8434:271::-;8564:3;8586:93;8675:3;8666:6;8586:93;:::i;:::-;8579:100;;8696:3;8689:10;;8434:271;;;;:::o

ipfs://7df8bcf4b4e68e09352c5809be3dc4cb9fcc6b1b6df05e3aaa3124d185489fe3