Contract 0xd23686a4da050ac3f64346096638f9dca9e67c21

/**
 *Submitted for verification at snowtrace.io on 2022-04-02
*/

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



pragma solidity ^0.8.0;

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

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

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

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

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

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

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

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

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

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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol



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

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


// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;



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

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

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

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

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

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

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

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

// File: contracts/lockTime.sol

pragma solidity ^0.8.0;


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

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

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

    /**
     * @dev Deploys a timelock instance that is able to hold the token specified, and will only release it to
     * `beneficiary_` when {release} is invoked after `releaseTime_`. The release time is specified as a Unix timestamp
     * (in seconds).
     */
    constructor(
        IERC20 token_,
        address beneficiary_,
        uint256 releaseTime_
    ) {
        require(releaseTime_ > block.timestamp, "TokenTimelock: release time is before current time");
        _token = token_;
        _beneficiary = beneficiary_;
        _releaseTime = releaseTime_;
    }

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

    /**
     * @dev Returns the beneficiary that will receive the tokens.
     */
    function beneficiary() public view virtual returns (address) {
        return _beneficiary;
    }

    /**
     * @dev Returns the time when the tokens are released in seconds since Unix epoch (i.e. Unix timestamp).
     */
    function releaseTime() public view virtual returns (uint256) {
        return _releaseTime;
    }

    /**
     * @dev Transfers tokens held by the timelock to the beneficiary. Will only succeed if invoked after the release
     * time.
     */
    function release() public virtual {
        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);
    }
}

[{"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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

000000000000000000000000277e3b8692b2d27403dbd5f25ee4c01684b8b8800000000000000000000000003ede05bcd0ad0492fdf46871cb794f47615a9592000000000000000000000000000000000000000000000000000000006429bca4

-----Decoded View---------------
Arg [0] : token_ (address): 0x277e3b8692b2d27403dbd5f25ee4c01684b8b880
Arg [1] : beneficiary_ (address): 0x3ede05bcd0ad0492fdf46871cb794f47615a9592
Arg [2] : releaseTime_ (uint256): 1680456868

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000277e3b8692b2d27403dbd5f25ee4c01684b8b880
Arg [1] : 0000000000000000000000003ede05bcd0ad0492fdf46871cb794f47615a9592
Arg [2] : 000000000000000000000000000000000000000000000000000000006429bca4

15220:2016:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16406:99;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;16898:335;;;:::i;:::-;;16641:99;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;16227:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;16406:99;16458:7;16485:12;16478:19;;16406:99;:::o;16898:335::-;16970:13;:11;:13::i;:::-;16951:15;:32;;16943:95;;;;;;;;;;;;:::i;:::-;;;;;;;;;17051:14;17068:7;:5;:7::i;:::-;:17;;;17094:4;17068:32;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;17051:49;;17128:1;17119:6;:10;17111:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;17182:43;17203:13;:11;:13::i;:::-;17218:6;17182:7;:5;:7::i;:::-;:20;;;;:43;;;;;:::i;:::-;16932:301;16898:335::o;16641:99::-;16693:7;16720:12;16713:19;;16641:99;:::o;16227:86::-;16273:6;16299;16292:13;;16227:86;:::o;11631:211::-;11748:86;11768:5;11798:23;;;11823:2;11827:5;11775:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11748:19;:86::i;:::-;11631:211;;;:::o;14204:716::-;14628:23;14654:69;14682:4;14654:69;;;;;;;;;;;;;;;;;14662:5;14654:27;;;;:69;;;;;:::i;:::-;14628:95;;14758:1;14738:10;:17;:21;14734:179;;;14835:10;14824:30;;;;;;;;;;;;:::i;:::-;14816:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;14734:179;14274:646;14204:716;;:::o;3572:229::-;3709:12;3741:52;3763:6;3771:4;3777:1;3780:12;3741:21;:52::i;:::-;3734:59;;3572:229;;;;;:::o;4692:510::-;4862:12;4920:5;4895:21;:30;;4887:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;4987:18;4998:6;4987:10;:18::i;:::-;4979:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;5053:12;5067:23;5094:6;:11;;5113:5;5120:4;5094:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5052:73;;;;5143:51;5160:7;5169:10;5181:12;5143:16;:51::i;:::-;5136:58;;;;4692:510;;;;;;:::o;766:387::-;826:4;1034:12;1101:7;1089:20;1081:28;;1144:1;1137:4;:8;1130:15;;;766:387;;;:::o;7378:712::-;7528:12;7557:7;7553:530;;;7588:10;7581:17;;;;7553:530;7722:1;7702:10;:17;:21;7698:374;;;7900:10;7894:17;7961:15;7948:10;7944:2;7940:19;7933:44;7698:374;8043:12;8036:20;;;;;;;;;;;:::i;:::-;;;;;;;;7378:712;;;;;;:::o;7:126:1:-;44:7;84:42;77:5;73:54;62:65;;7:126;;;:::o;139:96::-;176:7;205:24;223:5;205:24;:::i;:::-;194:35;;139:96;;;:::o;241:118::-;328:24;346:5;328:24;:::i;:::-;323:3;316:37;241:118;;:::o;365:222::-;458:4;496:2;485:9;481:18;473:26;;509:71;577:1;566:9;562:17;553:6;509:71;:::i;:::-;365:222;;;;:::o;593:77::-;630:7;659:5;648:16;;593:77;;;:::o;676:118::-;763:24;781:5;763:24;:::i;:::-;758:3;751:37;676:118;;:::o;800:222::-;893:4;931:2;920:9;916:18;908:26;;944:71;1012:1;1001:9;997:17;988:6;944:71;:::i;:::-;800:222;;;;:::o;1028:60::-;1056:3;1077:5;1070:12;;1028:60;;;:::o;1094:142::-;1144:9;1177:53;1195:34;1204:24;1222:5;1204:24;:::i;:::-;1195:34;:::i;:::-;1177:53;:::i;:::-;1164:66;;1094:142;;;:::o;1242:126::-;1292:9;1325:37;1356:5;1325:37;:::i;:::-;1312:50;;1242:126;;;:::o;1374:140::-;1438:9;1471:37;1502:5;1471:37;:::i;:::-;1458:50;;1374:140;;;:::o;1520:159::-;1621:51;1666:5;1621:51;:::i;:::-;1616:3;1609:64;1520:159;;:::o;1685:250::-;1792:4;1830:2;1819:9;1815:18;1807:26;;1843:85;1925:1;1914:9;1910:17;1901:6;1843:85;:::i;:::-;1685:250;;;;:::o;1941:169::-;2025:11;2059:6;2054:3;2047:19;2099:4;2094:3;2090:14;2075:29;;1941:169;;;;:::o;2116:237::-;2256:34;2252:1;2244:6;2240:14;2233:58;2325:20;2320:2;2312:6;2308:15;2301:45;2116:237;:::o;2359:366::-;2501:3;2522:67;2586:2;2581:3;2522:67;:::i;:::-;2515:74;;2598:93;2687:3;2598:93;:::i;:::-;2716:2;2711:3;2707:12;2700:19;;2359:366;;;:::o;2731:419::-;2897:4;2935:2;2924:9;2920:18;2912:26;;2984:9;2978:4;2974:20;2970:1;2959:9;2955:17;2948:47;3012:131;3138:4;3012:131;:::i;:::-;3004:139;;2731:419;;;:::o;3237:117::-;3346:1;3343;3336:12;3483:122;3556:24;3574:5;3556:24;:::i;:::-;3549:5;3546:35;3536:63;;3595:1;3592;3585:12;3536:63;3483:122;:::o;3611:143::-;3668:5;3699:6;3693:13;3684:22;;3715:33;3742:5;3715:33;:::i;:::-;3611:143;;;;:::o;3760:351::-;3830:6;3879:2;3867:9;3858:7;3854:23;3850:32;3847:119;;;3885:79;;:::i;:::-;3847:119;4005:1;4030:64;4086:7;4077:6;4066:9;4062:22;4030:64;:::i;:::-;4020:74;;3976:128;3760:351;;;;:::o;4117:222::-;4257:34;4253:1;4245:6;4241:14;4234:58;4326:5;4321:2;4313:6;4309:15;4302:30;4117:222;:::o;4345:366::-;4487:3;4508:67;4572:2;4567:3;4508:67;:::i;:::-;4501:74;;4584:93;4673:3;4584:93;:::i;:::-;4702:2;4697:3;4693:12;4686:19;;4345:366;;;:::o;4717:419::-;4883:4;4921:2;4910:9;4906:18;4898:26;;4970:9;4964:4;4960:20;4956:1;4945:9;4941:17;4934:47;4998:131;5124:4;4998:131;:::i;:::-;4990:139;;4717:419;;;:::o;5142:332::-;5263:4;5301:2;5290:9;5286:18;5278:26;;5314:71;5382:1;5371:9;5367:17;5358:6;5314:71;:::i;:::-;5395:72;5463:2;5452:9;5448:18;5439:6;5395:72;:::i;:::-;5142:332;;;;;:::o;5480:90::-;5514:7;5557:5;5550:13;5543:21;5532:32;;5480:90;;;:::o;5576:116::-;5646:21;5661:5;5646:21;:::i;:::-;5639:5;5636:32;5626:60;;5682:1;5679;5672:12;5626:60;5576:116;:::o;5698:137::-;5752:5;5783:6;5777:13;5768:22;;5799:30;5823:5;5799:30;:::i;:::-;5698:137;;;;:::o;5841:345::-;5908:6;5957:2;5945:9;5936:7;5932:23;5928:32;5925:119;;;5963:79;;:::i;:::-;5925:119;6083:1;6108:61;6161:7;6152:6;6141:9;6137:22;6108:61;:::i;:::-;6098:71;;6054:125;5841:345;;;;:::o;6192:229::-;6332:34;6328:1;6320:6;6316:14;6309:58;6401:12;6396:2;6388:6;6384:15;6377:37;6192:229;:::o;6427:366::-;6569:3;6590:67;6654:2;6649:3;6590:67;:::i;:::-;6583:74;;6666:93;6755:3;6666:93;:::i;:::-;6784:2;6779:3;6775:12;6768:19;;6427:366;;;:::o;6799:419::-;6965:4;7003:2;6992:9;6988:18;6980:26;;7052:9;7046:4;7042:20;7038:1;7027:9;7023:17;7016:47;7080:131;7206:4;7080:131;:::i;:::-;7072:139;;6799:419;;;:::o;7224:225::-;7364:34;7360:1;7352:6;7348:14;7341:58;7433:8;7428:2;7420:6;7416:15;7409:33;7224:225;:::o;7455:366::-;7597:3;7618:67;7682:2;7677:3;7618:67;:::i;:::-;7611:74;;7694:93;7783:3;7694:93;:::i;:::-;7812:2;7807:3;7803:12;7796:19;;7455:366;;;:::o;7827:419::-;7993:4;8031:2;8020:9;8016:18;8008:26;;8080:9;8074:4;8070:20;8066:1;8055:9;8051:17;8044:47;8108:131;8234:4;8108:131;:::i;:::-;8100:139;;7827:419;;;:::o;8252:179::-;8392:31;8388:1;8380:6;8376:14;8369:55;8252:179;:::o;8437:366::-;8579:3;8600:67;8664:2;8659:3;8600:67;:::i;:::-;8593:74;;8676:93;8765:3;8676:93;:::i;:::-;8794:2;8789:3;8785:12;8778:19;;8437:366;;;:::o;8809:419::-;8975:4;9013:2;9002:9;8998:18;8990:26;;9062:9;9056:4;9052:20;9048:1;9037:9;9033:17;9026:47;9090:131;9216:4;9090:131;:::i;:::-;9082:139;;8809:419;;;:::o;9234:98::-;9285:6;9319:5;9313:12;9303:22;;9234:98;;;:::o;9338:147::-;9439:11;9476:3;9461:18;;9338:147;;;;:::o;9491:307::-;9559:1;9569:113;9583:6;9580:1;9577:13;9569:113;;;9668:1;9663:3;9659:11;9653:18;9649:1;9644:3;9640:11;9633:39;9605:2;9602:1;9598:10;9593:15;;9569:113;;;9700:6;9697:1;9694:13;9691:101;;;9780:1;9771:6;9766:3;9762:16;9755:27;9691:101;9540:258;9491:307;;;:::o;9804:373::-;9908:3;9936:38;9968:5;9936:38;:::i;:::-;9990:88;10071:6;10066:3;9990:88;:::i;:::-;9983:95;;10087:52;10132:6;10127:3;10120:4;10113:5;10109:16;10087:52;:::i;:::-;10164:6;10159:3;10155:16;10148:23;;9912:265;9804:373;;;;:::o;10183:271::-;10313:3;10335:93;10424:3;10415:6;10335:93;:::i;:::-;10328:100;;10445:3;10438:10;;10183:271;;;;:::o;10460:99::-;10512:6;10546:5;10540:12;10530:22;;10460:99;;;:::o;10565:102::-;10606:6;10657:2;10653:7;10648:2;10641:5;10637:14;10633:28;10623:38;;10565:102;;;:::o;10673:364::-;10761:3;10789:39;10822:5;10789:39;:::i;:::-;10844:71;10908:6;10903:3;10844:71;:::i;:::-;10837:78;;10924:52;10969:6;10964:3;10957:4;10950:5;10946:16;10924:52;:::i;:::-;11001:29;11023:6;11001:29;:::i;:::-;10996:3;10992:39;10985:46;;10765:272;10673:364;;;;:::o;11043:313::-;11156:4;11194:2;11183:9;11179:18;11171:26;;11243:9;11237:4;11233:20;11229:1;11218:9;11214:17;11207:47;11271:78;11344:4;11335:6;11271:78;:::i;:::-;11263:86;;11043:313;;;;:::o

ipfs://d4b7d6c593066c2a3e47984ca61b1c5e0dd78eb84eb077d93c9c661fe5c2d19e