Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at Arbiscan.io on 2024-10-09
*/

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13 ^0.8.20;

// lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol

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

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

// lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Permit.sol

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

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

// lib/openzeppelin-contracts/contracts/utils/Address.sol

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

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

// lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol

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

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

// src/SimpleStaking_V1.sol

contract SimpleStaking_V1 {
    using SafeERC20 for IERC20;

    IERC20 public stakingToken;
    // sponsor[player][stakeAmount]
    mapping(address => mapping(bytes16 => uint256)) public stakeAmount;
    mapping(address => bytes16) public walletToOSID;

    event Stake(bytes16 indexed sponsor, bytes16 indexed player, uint256 amount);
    event Unstake(bytes16 indexed sponsor, bytes16 indexed player, uint256 amount);

    constructor(IERC20 _stakingToken) {
        stakingToken = _stakingToken;
    }

    function stake(bytes16 sponsor, bytes16 player, uint256 amount) public {
        _validateAmount(amount);
        walletToOSID[msg.sender] = sponsor;
        stakingToken.safeTransferFrom(msg.sender, address(this), amount);
        stakeAmount[msg.sender][player] += amount;
        emit Stake(sponsor, player, amount);
    }

    function unstake(bytes16 player, uint256 amount) public {
        _validateAmount(amount);
        stakeAmount[msg.sender][player] -= amount;
        stakingToken.safeTransfer(msg.sender, amount);
        emit Unstake(walletToOSID[msg.sender], player, amount);
    }

    function _validateAmount(uint256 _amount) internal pure {
        require(_amount != 0, "SS: Amount must be greater than 0");
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"_stakingToken","type":"address"}],"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":"bytes16","name":"sponsor","type":"bytes16"},{"indexed":true,"internalType":"bytes16","name":"player","type":"bytes16"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Stake","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes16","name":"sponsor","type":"bytes16"},{"indexed":true,"internalType":"bytes16","name":"player","type":"bytes16"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Unstake","type":"event"},{"inputs":[{"internalType":"bytes16","name":"sponsor","type":"bytes16"},{"internalType":"bytes16","name":"player","type":"bytes16"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"bytes16","name":"","type":"bytes16"}],"name":"stakeAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes16","name":"player","type":"bytes16"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"walletToOSID","outputs":[{"internalType":"bytes16","name":"","type":"bytes16"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000009aee3c99934c88832399d6c6e08ad802112ebeab

-----Decoded View---------------
Arg [0] : _stakingToken (address): 0x9aee3C99934C88832399D6C6E08ad802112eBEab

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000009aee3c99934c88832399d6c6e08ad802112ebeab

19060:1280:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19586:331;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;19198:66;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19128:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19271:47;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19925:271;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;19586:331;19668:23;19684:6;19668:15;:23::i;:::-;19729:7;19702:12;:24;19715:10;19702:24;;;;;;;;;;;;;;;;:34;;;;;;;;;;;;;;;;;;19747:64;19777:10;19797:4;19804:6;19747:12;;;;;;;;;;:29;;;;:64;;;;;;:::i;:::-;19857:6;19822:11;:23;19834:10;19822:23;;;;;;;;;;;;;;;:31;19846:6;19822:31;;;;;;;;;;;;;;;;;;:41;;;;;;;:::i;:::-;;;;;;;;19894:6;19879:30;;;19885:7;19879:30;;;;19902:6;19879:30;;;;;;:::i;:::-;;;;;;;;19586:331;;;:::o;19198:66::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;19128:26::-;;;;;;;;;;;;:::o;19271:47::-;;;;;;;;;;;;;;;;;;;;;;:::o;19925:271::-;19992:23;20008:6;19992:15;:23::i;:::-;20061:6;20026:11;:23;20038:10;20026:23;;;;;;;;;;;;;;;:31;20050:6;20026:31;;;;;;;;;;;;;;;;;;:41;;;;;;;:::i;:::-;;;;;;;;20078:45;20104:10;20116:6;20078:12;;;;;;;;;;:25;;;;:45;;;;;:::i;:::-;20173:6;20139:49;;;20147:12;:24;20160:10;20147:24;;;;;;;;;;;;;;;;;;;;;;;;;20139:49;;;;20181:6;20139:49;;;;;;:::i;:::-;;;;;;;;19925:271;;:::o;20204:133::-;20290:1;20279:7;:12;20271:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;20204:133;:::o;14884:190::-;14985:81;15005:5;15027;:18;;;15048:4;15054:2;15058:5;15012:53;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14985:19;:81::i;:::-;14884:190;;;;:::o;14477:162::-;14560:71;14580:5;14602;:14;;;14619:2;14623:5;14587:43;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14560:19;:71::i;:::-;14477:162;;;:::o;17288:638::-;17712:23;17738:33;17766:4;17746:5;17738:27;;;;:33;;;;:::i;:::-;17712:59;;17807:1;17786:10;:17;:22;;:57;;;;;17824:10;17813:30;;;;;;;;;;;;:::i;:::-;17812:31;17786:57;17782:137;;;17900:5;17867:40;;;;;;;;;;;:::i;:::-;;;;;;;;17782:137;17358:568;17288:638;;:::o;9632:153::-;9707:12;9739:38;9761:6;9769:4;9775:1;9739:21;:38::i;:::-;9732:45;;9632:153;;;;:::o;10120:398::-;10219:12;10272:5;10248:21;:29;10244:110;;;10336:4;10301:41;;;;;;;;;;;:::i;:::-;;;;;;;;10244:110;10365:12;10379:23;10406:6;:11;;10425:5;10432:4;10406:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10364:73;;;;10455:55;10482:6;10490:7;10499:10;10455:26;:55::i;:::-;10448:62;;;;10120:398;;;;;:::o;11596:597::-;11744:12;11774:7;11769:417;;11798:19;11806:10;11798:7;:19::i;:::-;11769:417;;;12047:1;12026:10;:17;:22;:49;;;;;12074:1;12052:6;:18;;;:23;12026:49;12022:121;;;12120:6;12103:24;;;;;;;;;;;:::i;:::-;;;;;;;;12022:121;12164:10;12157:17;;;;11769:417;11596:597;;;;;;:::o;12746:528::-;12899:1;12879:10;:17;:21;12875:392;;;13111:10;13105:17;13168:15;13155:10;13151:2;13147:19;13140:44;12875:392;13238:17;;;;;;;;;;;;;;88:117:1;197:1;194;187:12;334:150;371:7;411:66;404:5;400:78;389:89;;334:150;;;:::o;490:122::-;563:24;581:5;563:24;:::i;:::-;556:5;553:35;543:63;;602:1;599;592:12;543:63;490:122;:::o;618:139::-;664:5;702:6;689:20;680:29;;718:33;745:5;718:33;:::i;:::-;618:139;;;;:::o;763:77::-;800:7;829:5;818:16;;763:77;;;:::o;846:122::-;919:24;937:5;919:24;:::i;:::-;912:5;909:35;899:63;;958:1;955;948:12;899:63;846:122;:::o;974:139::-;1020:5;1058:6;1045:20;1036:29;;1074:33;1101:5;1074:33;:::i;:::-;974:139;;;;:::o;1119:619::-;1196:6;1204;1212;1261:2;1249:9;1240:7;1236:23;1232:32;1229:119;;;1267:79;;:::i;:::-;1229:119;1387:1;1412:53;1457:7;1448:6;1437:9;1433:22;1412:53;:::i;:::-;1402:63;;1358:117;1514:2;1540:53;1585:7;1576:6;1565:9;1561:22;1540:53;:::i;:::-;1530:63;;1485:118;1642:2;1668:53;1713:7;1704:6;1693:9;1689:22;1668:53;:::i;:::-;1658:63;;1613:118;1119:619;;;;;:::o;1744:126::-;1781:7;1821:42;1814:5;1810:54;1799:65;;1744:126;;;:::o;1876:96::-;1913:7;1942:24;1960:5;1942:24;:::i;:::-;1931:35;;1876:96;;;:::o;1978:122::-;2051:24;2069:5;2051:24;:::i;:::-;2044:5;2041:35;2031:63;;2090:1;2087;2080:12;2031:63;1978:122;:::o;2106:139::-;2152:5;2190:6;2177:20;2168:29;;2206:33;2233:5;2206:33;:::i;:::-;2106:139;;;;:::o;2251:474::-;2319:6;2327;2376:2;2364:9;2355:7;2351:23;2347:32;2344:119;;;2382:79;;:::i;:::-;2344:119;2502:1;2527:53;2572:7;2563:6;2552:9;2548:22;2527:53;:::i;:::-;2517:63;;2473:117;2629:2;2655:53;2700:7;2691:6;2680:9;2676:22;2655:53;:::i;:::-;2645:63;;2600:118;2251:474;;;;;:::o;2731:118::-;2818:24;2836:5;2818:24;:::i;:::-;2813:3;2806:37;2731:118;;:::o;2855:222::-;2948:4;2986:2;2975:9;2971:18;2963:26;;2999:71;3067:1;3056:9;3052:17;3043:6;2999:71;:::i;:::-;2855:222;;;;:::o;3083:60::-;3111:3;3132:5;3125:12;;3083:60;;;:::o;3149:142::-;3199:9;3232:53;3250:34;3259:24;3277:5;3259:24;:::i;:::-;3250:34;:::i;:::-;3232:53;:::i;:::-;3219:66;;3149:142;;;:::o;3297:126::-;3347:9;3380:37;3411:5;3380:37;:::i;:::-;3367:50;;3297:126;;;:::o;3429:139::-;3492:9;3525:37;3556:5;3525:37;:::i;:::-;3512:50;;3429:139;;;:::o;3574:157::-;3674:50;3718:5;3674:50;:::i;:::-;3669:3;3662:63;3574:157;;:::o;3737:248::-;3843:4;3881:2;3870:9;3866:18;3858:26;;3894:84;3975:1;3964:9;3960:17;3951:6;3894:84;:::i;:::-;3737:248;;;;:::o;3991:329::-;4050:6;4099:2;4087:9;4078:7;4074:23;4070:32;4067:119;;;4105:79;;:::i;:::-;4067:119;4225:1;4250:53;4295:7;4286:6;4275:9;4271:22;4250:53;:::i;:::-;4240:63;;4196:117;3991:329;;;;:::o;4326:118::-;4413:24;4431:5;4413:24;:::i;:::-;4408:3;4401:37;4326:118;;:::o;4450:222::-;4543:4;4581:2;4570:9;4566:18;4558:26;;4594:71;4662:1;4651:9;4647:17;4638:6;4594:71;:::i;:::-;4450:222;;;;:::o;4678:474::-;4746:6;4754;4803:2;4791:9;4782:7;4778:23;4774:32;4771:119;;;4809:79;;:::i;:::-;4771:119;4929:1;4954:53;4999:7;4990:6;4979:9;4975:22;4954:53;:::i;:::-;4944:63;;4900:117;5056:2;5082:53;5127:7;5118:6;5107:9;5103:22;5082:53;:::i;:::-;5072:63;;5027:118;4678:474;;;;;:::o;5158:180::-;5206:77;5203:1;5196:88;5303:4;5300:1;5293:15;5327:4;5324:1;5317:15;5344:191;5384:3;5403:20;5421:1;5403:20;:::i;:::-;5398:25;;5437:20;5455:1;5437:20;:::i;:::-;5432:25;;5480:1;5477;5473:9;5466:16;;5501:3;5498:1;5495:10;5492:36;;;5508:18;;:::i;:::-;5492:36;5344:191;;;;:::o;5541:194::-;5581:4;5601:20;5619:1;5601:20;:::i;:::-;5596:25;;5635:20;5653:1;5635:20;:::i;:::-;5630:25;;5679:1;5676;5672:9;5664:17;;5703:1;5697:4;5694:11;5691:37;;;5708:18;;:::i;:::-;5691:37;5541:194;;;;:::o;5741:169::-;5825:11;5859:6;5854:3;5847:19;5899:4;5894:3;5890:14;5875:29;;5741:169;;;;:::o;5916:220::-;6056:34;6052:1;6044:6;6040:14;6033:58;6125:3;6120:2;6112:6;6108:15;6101:28;5916:220;:::o;6142:366::-;6284:3;6305:67;6369:2;6364:3;6305:67;:::i;:::-;6298:74;;6381:93;6470:3;6381:93;:::i;:::-;6499:2;6494:3;6490:12;6483:19;;6142:366;;;:::o;6514:419::-;6680:4;6718:2;6707:9;6703:18;6695:26;;6767:9;6761:4;6757:20;6753:1;6742:9;6738:17;6731:47;6795:131;6921:4;6795:131;:::i;:::-;6787:139;;6514:419;;;:::o;6939:118::-;7026:24;7044:5;7026:24;:::i;:::-;7021:3;7014:37;6939:118;;:::o;7063:442::-;7212:4;7250:2;7239:9;7235:18;7227:26;;7263:71;7331:1;7320:9;7316:17;7307:6;7263:71;:::i;:::-;7344:72;7412:2;7401:9;7397:18;7388:6;7344:72;:::i;:::-;7426;7494:2;7483:9;7479:18;7470:6;7426:72;:::i;:::-;7063:442;;;;;;:::o;7511:332::-;7632:4;7670:2;7659:9;7655:18;7647:26;;7683:71;7751:1;7740:9;7736:17;7727:6;7683:71;:::i;:::-;7764:72;7832:2;7821:9;7817:18;7808:6;7764:72;:::i;:::-;7511:332;;;;;:::o;7849:90::-;7883:7;7926:5;7919:13;7912:21;7901:32;;7849:90;;;:::o;7945:116::-;8015:21;8030:5;8015:21;:::i;:::-;8008:5;8005:32;7995:60;;8051:1;8048;8041:12;7995:60;7945:116;:::o;8067:137::-;8121:5;8152:6;8146:13;8137:22;;8168:30;8192:5;8168:30;:::i;:::-;8067:137;;;;:::o;8210:345::-;8277:6;8326:2;8314:9;8305:7;8301:23;8297:32;8294:119;;;8332:79;;:::i;:::-;8294:119;8452:1;8477:61;8530:7;8521:6;8510:9;8506:22;8477:61;:::i;:::-;8467:71;;8423:125;8210:345;;;;:::o;8561:222::-;8654:4;8692:2;8681:9;8677:18;8669:26;;8705:71;8773:1;8762:9;8758:17;8749:6;8705:71;:::i;:::-;8561:222;;;;:::o;8789:98::-;8840:6;8874:5;8868:12;8858:22;;8789:98;;;:::o;8893:147::-;8994:11;9031:3;9016:18;;8893:147;;;;:::o;9046:139::-;9135:6;9130:3;9125;9119:23;9176:1;9167:6;9162:3;9158:16;9151:27;9046:139;;;:::o;9191:386::-;9295:3;9323:38;9355:5;9323:38;:::i;:::-;9377:88;9458:6;9453:3;9377:88;:::i;:::-;9370:95;;9474:65;9532:6;9527:3;9520:4;9513:5;9509:16;9474:65;:::i;:::-;9564:6;9559:3;9555:16;9548:23;;9299:278;9191:386;;;;:::o;9583:271::-;9713:3;9735:93;9824:3;9815:6;9735:93;:::i;:::-;9728:100;;9845:3;9838:10;;9583:271;;;;:::o

ipfs://510118cda836a1e615b363fdfde1859234c6d56b3bc80df6b73b814b8c165efd