Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(address ...
•    - function _verifyCallResult(bool succe ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function _callOptionalReturn(IERC20 t ...
•  contract TokenTimelock *
•    - function token()
•    - function beneficiary()
•    - function releaseTime()
•    - function release()

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at ftmscan.com on 2021-05-04
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;



/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}


/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

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

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}


/**
 * @dev A token holder contract that will allow a beneficiary to extract the
 * tokens after a given release time.
 *
 * Useful for simple vesting schedules like "advisors get all of their tokens
 * after 1 year".
 */
contract TokenTimelock {
    using SafeERC20 for IERC20;

    // ERC20 basic token contract being held
    IERC20 immutable private _token;

    // beneficiary of tokens after they are released
    address immutable private _beneficiary;

    // timestamp when token release is enabled
    uint256 immutable private _releaseTime;

    constructor (IERC20 token_, address beneficiary_, uint256 releaseTime_) {
        // solhint-disable-next-line not-rely-on-time
        require(releaseTime_ > block.timestamp, "TokenTimelock: release time is before current time");
        _token = token_;
        _beneficiary = beneficiary_;
        _releaseTime = releaseTime_;
    }

    /**
     * @return the token being held.
     */
    function token() public view virtual returns (IERC20) {
        return _token;
    }

    /**
     * @return the beneficiary of the tokens.
     */
    function beneficiary() public view virtual returns (address) {
        return _beneficiary;
    }

    /**
     * @return the time when the tokens are released.
     */
    function releaseTime() public view virtual returns (uint256) {
        return _releaseTime;
    }

    /**
     * @notice Transfers tokens held by timelock to beneficiary.
     */
    function release() public virtual {
        // solhint-disable-next-line not-rely-on-time
        require(block.timestamp >= releaseTime(), "TokenTimelock: current time is before release time");

        uint256 amount = token().balanceOf(address(this));
        require(amount > 0, "TokenTimelock: no tokens to release");

        token().safeTransfer(beneficiary(), amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"token_","type":"address"},{"internalType":"address","name":"beneficiary_","type":"address"},{"internalType":"uint256","name":"releaseTime_","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"beneficiary","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"releaseTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

0x608060405234801561001057600080fd5b506004361061004c5760003560e01c806338af3eed1461005157806386d1a69f1461006f578063b91d400114610079578063fc0c546a1461008e575b600080fd5b610059610096565b6040516100669190610571565b60405180910390f35b6100776100ba565b005b610081610206565b60405161006691906107b4565b61005961022a565b7f00000000000000000000000095478c4f7d22d1048f46100001c2c69d2ba5738090565b6100c2610206565b421015610104576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100fb90610609565b60405180910390fd5b600061010e61022a565b73ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016101469190610571565b60206040518083038186803b15801561015e57600080fd5b505afa158015610172573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610196919061053d565b9050600081116101d2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100fb90610757565b6102036101dd610096565b826101e661022a565b73ffffffffffffffffffffffffffffffffffffffff16919061024e565b50565b7f0000000000000000000000000000000000000000000000000000000060e0e19190565b7f000000000000000000000000841fad6eae12c286d1fd18d1d525dffa75c7effe90565b6102ef8363a9059cbb60e01b848460405160240161026d929190610592565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff00000000000000000000000000000000000000000000000000000000909316929092179091526102f4565b505050565b6000610356826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166103aa9092919063ffffffff16565b8051909150156102ef5780806020019051810190610374919061051d565b6102ef576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100fb906106fa565b60606103b984846000856103c3565b90505b9392505050565b6060824710156103ff576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100fb90610666565b610408856104c4565b61043e576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100fb906106c3565b6000808673ffffffffffffffffffffffffffffffffffffffff1685876040516104679190610555565b60006040518083038185875af1925050503d80600081146104a4576040519150601f19603f3d011682016040523d82523d6000602084013e6104a9565b606091505b50915091506104b98282866104ca565b979650505050505050565b3b151590565b606083156104d95750816103bc565b8251156104e95782518084602001fd5b816040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100fb91906105b8565b60006020828403121561052e578081fd5b815180151581146103bc578182fd5b60006020828403121561054e578081fd5b5051919050565b600082516105678184602087016107bd565b9190910192915050565b73ffffffffffffffffffffffffffffffffffffffff91909116815260200190565b73ffffffffffffffffffffffffffffffffffffffff929092168252602082015260400190565b60006020825282518060208401526105d78160408501602087016107bd565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169190910160400192915050565b60208082526032908201527f546f6b656e54696d656c6f636b3a2063757272656e742074696d65206973206260408201527f65666f72652072656c656173652074696d650000000000000000000000000000606082015260800190565b60208082526026908201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60408201527f722063616c6c0000000000000000000000000000000000000000000000000000606082015260800190565b6020808252601d908201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604082015260600190565b6020808252602a908201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60408201527f6f74207375636365656400000000000000000000000000000000000000000000606082015260800190565b60208082526023908201527f546f6b656e54696d656c6f636b3a206e6f20746f6b656e7320746f2072656c6560408201527f6173650000000000000000000000000000000000000000000000000000000000606082015260800190565b90815260200190565b60005b838110156107d85781810151838201526020016107c0565b838111156107e7576000848401525b5050505056fea26469706673582212209078ff6142aa2214d6f4f271609b8352e50b4f6576dc7b04e54b3db19e71bf2e64736f6c63430008000033

000000000000000000000000841fad6eae12c286d1fd18d1d525dffa75c7effe00000000000000000000000095478c4f7d22d1048f46100001c2c69d2ba573800000000000000000000000000000000000000000000000000000000060e0e191

-----Decoded View---------------
Arg [0] : token_ (address): 0x841FAD6EAe12c286d1Fd18d1d525DFfA75C7EFFE
Arg [1] : beneficiary_ (address): 0x95478C4F7D22D1048F46100001c2C69D2BA57380
Arg [2] : releaseTime_ (uint256): 1625350545

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000841fad6eae12c286d1fd18d1d525dffa75c7effe
Arg [1] : 00000000000000000000000095478c4f7d22d1048f46100001c2c69d2ba57380
Arg [2] : 0000000000000000000000000000000000000000000000000000000060e0e191

14682:1675:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15593:99;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15964:390;;;:::i;:::-;;15773:99;;;:::i;:::-;;;;;;;:::i;15434:86::-;;;:::i;15593:99::-;15672:12;15593:99;:::o;15964:390::-;16091:13;:11;:13::i;:::-;16072:15;:32;;16064:95;;;;;;;;;;;;:::i;:::-;;;;;;;;;16172:14;16189:7;:5;:7::i;:::-;:17;;;16215:4;16189:32;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16172:49;;16249:1;16240:6;:10;16232:58;;;;;;;;;;;;:::i;:::-;16303:43;16324:13;:11;:13::i;:::-;16339:6;16303:7;:5;:7::i;:::-;:20;;;:43;:20;:43::i;:::-;15964:390;:::o;15773:99::-;15852:12;15773:99;:::o;15434:86::-;15506:6;15434:86;:::o;11249:177::-;11332:86;11352:5;11382:23;;;11407:2;11411:5;11359:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11332:19;:86::i;:::-;11249:177;;;:::o;13683:761::-;14107:23;14133:69;14161:4;14133:69;;;;;;;;;;;;;;;;;14141:5;14133:27;;;;:69;;;;;:::i;:::-;14217:17;;14107:95;;-1:-1:-1;14217:21:0;14213:224;;14359:10;14348:30;;;;;;;;;;;;:::i;:::-;14340:85;;;;;;;;;;;;:::i;6380:195::-;6483:12;6515:52;6537:6;6545:4;6551:1;6554:12;6515:21;:52::i;:::-;6508:59;;6380:195;;;;;;:::o;7432:530::-;7559:12;7617:5;7592:21;:30;;7584:81;;;;;;;;;;;;:::i;:::-;7684:18;7695:6;7684:10;:18::i;:::-;7676:60;;;;;;;;;;;;:::i;:::-;7810:12;7824:23;7851:6;:11;;7871:5;7879:4;7851:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7809:75;;;;7902:52;7920:7;7929:10;7941:12;7902:17;:52::i;:::-;7895:59;7432:530;-1:-1:-1;;;;;;;7432:530:0:o;3462:422::-;3829:20;3868:8;;;3462:422::o;9972:742::-;10087:12;10116:7;10112:595;;;-1:-1:-1;10147:10:0;10140:17;;10112:595;10261:17;;:21;10257:439;;10524:10;10518:17;10585:15;10572:10;10568:2;10564:19;10557:44;10472:148;10667:12;10660:20;;;;;;;;;;;:::i;14:297:1:-;;134:2;122:9;113:7;109:23;105:32;102:2;;;155:6;147;140:22;102:2;192:9;186:16;245:5;238:13;231:21;224:5;221:32;211:2;;272:6;264;257:22;316:194;;439:2;427:9;418:7;414:23;410:32;407:2;;;460:6;452;445:22;407:2;-1:-1:-1;488:16:1;;397:113;-1:-1:-1;397:113:1:o;515:274::-;;682:6;676:13;698:53;744:6;739:3;732:4;724:6;720:17;698:53;:::i;:::-;767:16;;;;;652:137;-1:-1:-1;;652:137:1:o;794:226::-;970:42;958:55;;;;940:74;;928:2;913:18;;895:125::o;1025:297::-;1229:42;1217:55;;;;1199:74;;1304:2;1289:18;;1282:34;1187:2;1172:18;;1154:168::o;1571:442::-;;1720:2;1709:9;1702:21;1752:6;1746:13;1795:6;1790:2;1779:9;1775:18;1768:34;1811:66;1870:6;1865:2;1854:9;1850:18;1845:2;1837:6;1833:15;1811:66;:::i;:::-;1929:2;1917:15;1934:66;1913:88;1898:104;;;;2004:2;1894:113;;1692:321;-1:-1:-1;;1692:321:1:o;2018:414::-;2220:2;2202:21;;;2259:2;2239:18;;;2232:30;2298:34;2293:2;2278:18;;2271:62;2369:20;2364:2;2349:18;;2342:48;2422:3;2407:19;;2192:240::o;2437:402::-;2639:2;2621:21;;;2678:2;2658:18;;;2651:30;2717:34;2712:2;2697:18;;2690:62;2788:8;2783:2;2768:18;;2761:36;2829:3;2814:19;;2611:228::o;2844:353::-;3046:2;3028:21;;;3085:2;3065:18;;;3058:30;3124:31;3119:2;3104:18;;3097:59;3188:2;3173:18;;3018:179::o;3202:406::-;3404:2;3386:21;;;3443:2;3423:18;;;3416:30;3482:34;3477:2;3462:18;;3455:62;3553:12;3548:2;3533:18;;3526:40;3598:3;3583:19;;3376:232::o;3613:399::-;3815:2;3797:21;;;3854:2;3834:18;;;3827:30;3893:34;3888:2;3873:18;;3866:62;3964:5;3959:2;3944:18;;3937:33;4002:3;3987:19;;3787:225::o;4017:177::-;4163:25;;;4151:2;4136:18;;4118:76::o;4199:258::-;4271:1;4281:113;4295:6;4292:1;4289:13;4281:113;;;4371:11;;;4365:18;4352:11;;;4345:39;4317:2;4310:10;4281:113;;;4412:6;4409:1;4406:13;4403:2;;;4447:1;4438:6;4433:3;4429:16;4422:27;4403:2;;4252:205;;;:::o

ipfs://9078ff6142aa2214d6f4f271609b8352e50b4f6576dc7b04e54b3db19e71bf2e