Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

   - function _nonReentrantBefore()    - function _nonReentrantAfter()    - function _reentrancyGuardEntered() library Address    - function sendValue(address payable re ...    - function functionCall(address target, ...    - function functionCallWithValue(addres ...    - function functionStaticCall(address t ...    - function functionDelegateCall(address ...    - function verifyCallResultFromTarget(    - function verifyCallResult(bool succes ...    - function _revert(bytes memory returnd ... interface IERC20Permit    - function permit(    - function nonces(address owner)    - function DOMAIN_SEPARATOR() interface IERC20Errors interface IERC721Errors interface IERC1155Errors    - function _msgSender()    - function _msgData()    - function _contextSuffixLength() interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address from, a ... library SafeERC20    - function safeTransfer(IERC20 token, a ...    - function safeTransferFrom(IERC20 toke ...    - function safeIncreaseAllowance(IERC20 ...    - function safeDecreaseAllowance(IERC20 ...    - function forceApprove(IERC20 token, a ...    - function _callOptionalReturn(IERC20 t ...    - function _callOptionalReturnBool(IERC ...  contract TimeLock is ReentrancyGua ...    - function release() interface IERC20Metadata is IERC20    - function name()    - function symbol()    - function decimals()    - function name()    - function symbol()    - function decimals()    - 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 ...    - function _transfer(address from, addr ...    - function _update(address from, addres ...    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _approve(address owner, addr ...    - function _approve(address owner, addr ...    - function _spendAllowance(address owne ...    - function burn(uint256 value)    - function burnFrom(address account, ui ...  contract Apexrom is ERC20, ERC20Bu ... *    - function formatTimeString(uint256 tim ...    - function getDay(uint256 timestamp)    - function getMonth(uint256 timestamp)    - function getYear(uint256 timestamp)    - function getTime(uint256 timestamp)    - function uint2str(uint256 _i)    - function transfer(address recipient, ...    - function transferFrom(address sender, ...

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at polygonscan.com on 2024-02-12
*/

// SPDX-License-Identifier: MIT

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

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


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

pragma solidity ^0.8.20;

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

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

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

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

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

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

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

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

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

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

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


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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

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


// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

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


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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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


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

pragma solidity ^0.8.20;




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

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

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

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

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

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

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

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

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

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

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

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

// File: TimeLock.sol


pragma solidity ^0.8.21;



contract TimeLock is ReentrancyGuard {
    using SafeERC20 for IERC20;

    IERC20 public token;
    address public beneficiary;
    uint256 public releaseTime;

    constructor(IERC20 _token, address _beneficiary, uint256 _releaseTime) {
        token = _token;
        beneficiary = _beneficiary;
        releaseTime = _releaseTime;
    }

    function release() external nonReentrant {
        require(block.timestamp >= releaseTime, "Release time not reached");
        uint256 amount = token.balanceOf(address(this));
        require(amount > 0, "No tokens to release");
        token.safeTransfer(beneficiary, amount);
    }
}
// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


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

pragma solidity ^0.8.20;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

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


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

pragma solidity ^0.8.20;





/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 8;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     * ```
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

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


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

pragma solidity ^0.8.20;



/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys a `value` amount of tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 value) public virtual {
        _burn(_msgSender(), value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, deducting from
     * the caller's allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `value`.
     */
    function burnFrom(address account, uint256 value) public virtual {
        _spendAllowance(account, _msgSender(), value);
        _burn(account, value);
    }
}

// File: APR.sol


pragma solidity ^0.8.21;




contract Apexrom is ERC20, ERC20Burnable {
    uint8 private constant _decimals = 8;

    mapping(address => TimeLock) public timeLocks;

    constructor() ERC20("Apexrom", "APR") {
        _mint(msg.sender, 990000000 * (10**uint256(_decimals)));


        address[20] memory beneficiaries = [
            0xa105Bee0e346319d36C7ea62c14E95D3dBD04187,
            0xAbEB2d239b4012328Eae7190f9f4ff37AFB8E248,
            0xEe39a19fD583DcA0f151956ce7a3525958ad9f5C,
            0x11848085b0a8A4222618B7b011C716dc01B945e2,
            0x2b91095158A6155281A35b1b8ADEED760f1d0a04,
			0x0f9684b86F9E03CB12a8695511e38144Be3D0b3A,
			0x54D1D1dBE86989C535Bb30a7159866285651D494,
			0x1F328EEc06e116B9ef91F8DF151464A71B6b9e15,
			0xB36Bc3B763858FdEF29f7140299525f7440Fb4cc,
			0x604e8fff92611b0e40644353c534B68Cce2fD85a,
			0x32F5d46C073b78793D065226F3415845d5d51Eeb,
			0x013fc242d21a29aaC750c6c52F95d164Fa34B3d7,
			0x331d8547545Eca2e8D233e08594Ab64FECDA1529,
			0xc2A1F343Ef120B3F85098D6990d3696104E4C22B,
			0x281a3F7Fc70300a803Edbeca32188568f4a7f576,
			0x07e3d084B467Cf18Fe8EFAB13e93eB728844262F,
			0x3012De6825046817Fd74Ed8A0CA405E7e98C434D,
			0x21a912E3441C78D894ec9732D1BA371c03948A68,
			0x778314077Ea848e9c129d188a6E938A9021B5844,
			0x7820C870F4d9E28063192AEaEf5e68b95Fb55b51
        ];

        uint256[20] memory releaseTimes = [
            block.timestamp + 747 days,
            block.timestamp + 1478 days,
            block.timestamp + 2208 days,
            block.timestamp + 2939 days,
            block.timestamp + 712 days,
			block.timestamp + 1442 days,
			block.timestamp + 2173 days,
			block.timestamp + 2903 days,
			block.timestamp + 378 days,
			block.timestamp + 743 days,
			block.timestamp + 1108 days,
			block.timestamp + 1473 days,
			block.timestamp + 498 days,
			block.timestamp + 1228 days,
			block.timestamp + 1959 days,
			block.timestamp + 3055 days,
			block.timestamp + 4150 days,
			block.timestamp + 4881 days,
			block.timestamp + 5611 days,
			block.timestamp + 6707 days
        ];

        for (uint256 i = 0; i < beneficiaries.length; i++) {
            timeLocks[beneficiaries[i]] = new TimeLock(IERC20(address(this)), beneficiaries[i], releaseTimes[i]);
        }
    }

   modifier canTransfer(address sender, uint256 amount) {
    if (timeLocks[sender] != TimeLock(address(0))) {
        uint256 releaseTime = timeLocks[sender].releaseTime();
        require(block.timestamp >= releaseTime, string(abi.encodePacked("Token transfer locked until ", formatTimeString(releaseTime))));
    }
    _;
}

function formatTimeString(uint256 timestamp) internal pure returns (string memory) {
    return
        string(
            abi.encodePacked(
                getDay(timestamp), " ",
                getMonth(timestamp), " ",
                getYear(timestamp), " ",
                getTime(timestamp)
            )
        );
}

function getDay(uint256 timestamp) internal pure returns (string memory) {
    return uint2str((timestamp / 86400) % 30 + 1);
}

function getMonth(uint256 timestamp) internal pure returns (string memory) {
    return uint2str((timestamp / 2629743) % 12 + 1);
}

function getYear(uint256 timestamp) internal pure returns (string memory) {
    return uint2str((timestamp / 31556926) + 1970);
}

function getTime(uint256 timestamp) internal pure returns (string memory) {
    return
        string(
            abi.encodePacked(
                uint2str((timestamp / 3600) % 24), ":",
                uint2str((timestamp / 60) % 60)
            )
        );
}

function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
    if (_i == 0) {
        return "0";
    }
    uint256 j = _i;
    uint256 length;
    while (j != 0) {
        length++;
        j /= 10;
    }
    bytes memory bstr = new bytes(length);
    uint256 k = length;
    j = _i;
    while (j != 0) {
        bstr[--k] = bytes1(uint8(48 + j % 10));
        j /= 10;
    }
    return string(bstr);
}

    function transfer(address recipient, uint256 amount) public override canTransfer(msg.sender, amount) returns (bool) {
        return super.transfer(recipient, amount);
    }

    function transferFrom(address sender, address recipient, uint256 amount) public override canTransfer(sender, amount) returns (bool) {
        return super.transferFrom(sender, recipient, amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"timeLocks","outputs":[{"internalType":"contract TimeLock","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

608060405234801562000010575f80fd5b506040518060400160405280600781526020017f41706578726f6d000000000000000000000000000000000000000000000000008152506040518060400160405280600381526020017f415052000000000000000000000000000000000000000000000000000000000081525081600390816200008e919062000e83565b508060049081620000a0919062000e83565b505050620000d833600860ff16600a620000bb9190620010e4565b633b023380620000cc919062001134565b6200096360201b60201c565b5f60405180610280016040528073a105bee0e346319d36c7ea62c14e95d3dbd0418773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200173abeb2d239b4012328eae7190f9f4ff37afb8e24873ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200173ee39a19fd583dca0f151956ce7a3525958ad9f5c73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020017311848085b0a8a4222618b7b011c716dc01b945e273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001732b91095158a6155281a35b1b8adeed760f1d0a0473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001730f9684b86f9e03cb12a8695511e38144be3d0b3a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020017354d1d1dbe86989c535bb30a7159866285651d49473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001731f328eec06e116b9ef91f8df151464a71b6b9e1573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200173b36bc3b763858fdef29f7140299525f7440fb4cc73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200173604e8fff92611b0e40644353c534b68cce2fd85a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020017332f5d46c073b78793d065226f3415845d5d51eeb73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200173013fc242d21a29aac750c6c52f95d164fa34b3d773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200173331d8547545eca2e8d233e08594ab64fecda152973ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200173c2a1f343ef120b3f85098d6990d3696104e4c22b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200173281a3f7fc70300a803edbeca32188568f4a7f57673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020017307e3d084b467cf18fe8efab13e93eb728844262f73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001733012de6825046817fd74ed8a0ca405e7e98c434d73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020017321a912e3441c78d894ec9732d1ba371c03948a6873ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200173778314077ea848e9c129d188a6e938a9021b584473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001737820c870f4d9e28063192aeaef5e68b95fb55b5173ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681525090505f6040518061028001604052806303d8d080426200067c91906200117e565b815260200163079c8900426200069391906200117e565b8152602001630b5ef00042620006aa91906200117e565b8152602001630f22a88042620006c191906200117e565b81526020016303aaac0042620006d891906200117e565b815260200163076d130042620006ef91906200117e565b8152602001630b30cb80426200070691906200117e565b8152602001630ef33280426200071d91906200117e565b81526020016301f25700426200073491906200117e565b81526020016303d38a80426200074b91906200117e565b81526020016305b4be00426200076291906200117e565b8152602001630795f180426200077991906200117e565b81526020016302908b00426200079091906200117e565b8152602001630652f20042620007a791906200117e565b8152602001630a16aa8042620007be91906200117e565b8152602001630fbb968042620007d591906200117e565b815260200163155f310042620007ec91906200117e565b8152602001631922e980426200080391906200117e565b8152602001631ce55080426200081a91906200117e565b815260200163228a3c80426200083191906200117e565b81525090505f5b60148110156200095a5730838260148110620008595762000858620011b8565b5b6020020151838360148110620008745762000873620011b8565b5b6020020151604051620008879062000c11565b620008959392919062001297565b604051809103905ff080158015620008af573d5f803e3d5ffd5b5060055f858460148110620008c957620008c8620011b8565b5b602002015173ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080806200095190620012d2565b91505062000838565b5050506200138f565b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603620009d6575f6040517fec442f05000000000000000000000000000000000000000000000000000000008152600401620009cd91906200131e565b60405180910390fd5b620009e95f8383620009ed60201b60201c565b5050565b5f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff160362000a41578060025f82825462000a3491906200117e565b9250508190555062000b12565b5f805f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205490508181101562000acd578381836040517fe450d38c00000000000000000000000000000000000000000000000000000000815260040162000ac49392919062001339565b60405180910390fd5b8181035f808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2081905550505b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff160362000b5b578060025f828254039250508190555062000ba5565b805f808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f82825401925050819055505b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8360405162000c04919062001374565b60405180910390a3505050565b610bae8062002d7883390190565b5f81519050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b5f600282049050600182168062000c9b57607f821691505b60208210810362000cb15762000cb062000c56565b5b50919050565b5f819050815f5260205f209050919050565b5f6020601f8301049050919050565b5f82821b905092915050565b5f6008830262000d157fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8262000cd8565b62000d21868362000cd8565b95508019841693508086168417925050509392505050565b5f819050919050565b5f819050919050565b5f62000d6b62000d6562000d5f8462000d39565b62000d42565b62000d39565b9050919050565b5f819050919050565b62000d868362000d4b565b62000d9e62000d958262000d72565b84845462000ce4565b825550505050565b5f90565b62000db462000da6565b62000dc181848462000d7b565b505050565b5b8181101562000de85762000ddc5f8262000daa565b60018101905062000dc7565b5050565b601f82111562000e375762000e018162000cb7565b62000e0c8462000cc9565b8101602085101562000e1c578190505b62000e3462000e2b8562000cc9565b83018262000dc6565b50505b505050565b5f82821c905092915050565b5f62000e595f198460080262000e3c565b1980831691505092915050565b5f62000e73838362000e48565b9150826002028217905092915050565b62000e8e8262000c1f565b67ffffffffffffffff81111562000eaa5762000ea962000c29565b5b62000eb6825462000c83565b62000ec382828562000dec565b5f60209050601f83116001811462000ef9575f841562000ee4578287015190505b62000ef0858262000e66565b86555062000f5f565b601f19841662000f098662000cb7565b5f5b8281101562000f325784890151825560018201915060208501945060208101905062000f0b565b8683101562000f52578489015162000f4e601f89168262000e48565b8355505b6001600288020188555050505b505050505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f8160011c9050919050565b5f808291508390505b600185111562000ff15780860481111562000fc95762000fc862000f67565b5b600185161562000fd95780820291505b808102905062000fe98562000f94565b945062000fa9565b94509492505050565b5f826200100b5760019050620010dd565b816200101a575f9050620010dd565b81600181146200103357600281146200103e5762001074565b6001915050620010dd565b60ff84111562001053576200105262000f67565b5b8360020a9150848211156200106d576200106c62000f67565b5b50620010dd565b5060208310610133831016604e8410600b8410161715620010ae5782820a905083811115620010a857620010a762000f67565b5b620010dd565b620010bd848484600162000fa0565b92509050818404811115620010d757620010d662000f67565b5b81810290505b9392505050565b5f620010f08262000d39565b9150620010fd8362000d39565b92506200112c7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff848462000ffa565b905092915050565b5f620011408262000d39565b91506200114d8362000d39565b92508282026200115d8162000d39565b9150828204841483151762001177576200117662000f67565b5b5092915050565b5f6200118a8262000d39565b9150620011978362000d39565b9250828201905080821115620011b257620011b162000f67565b5b92915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f620012246200121e6200121884620011e5565b62000d42565b620011e5565b9050919050565b5f620012378262001204565b9050919050565b5f6200124a826200122b565b9050919050565b6200125c816200123e565b82525050565b5f6200126e82620011e5565b9050919050565b620012808162001262565b82525050565b620012918162000d39565b82525050565b5f606082019050620012ac5f83018662001251565b620012bb602083018562001275565b620012ca604083018462001286565b949350505050565b5f620012de8262000d39565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff820362001313576200131262000f67565b5b600182019050919050565b5f602082019050620013335f83018462001275565b92915050565b5f6060820190506200134e5f83018662001275565b6200135d602083018562001286565b6200136c604083018462001286565b949350505050565b5f602082019050620013895f83018462001286565b92915050565b6119db806200139d5f395ff3fe608060405234801561000f575f80fd5b50600436106100b2575f3560e01c806370a082311161006f57806370a082311461018c57806379cc6790146101bc5780637f76b223146101d857806395d89b4114610208578063a9059cbb14610226578063dd62ed3e14610256576100b2565b806306fdde03146100b6578063095ea7b3146100d457806318160ddd1461010457806323b872dd14610122578063313ce5671461015257806342966c6814610170575b5f80fd5b6100be610286565b6040516100cb919061125c565b60405180910390f35b6100ee60048036038101906100e9919061130d565b610316565b6040516100fb9190611365565b60405180910390f35b61010c610338565b604051610119919061138d565b60405180910390f35b61013c600480360381019061013791906113a6565b610341565b6040516101499190611365565b60405180910390f35b61015a610525565b6040516101679190611411565b60405180910390f35b61018a6004803603810190610185919061142a565b61052d565b005b6101a660048036038101906101a19190611455565b610541565b6040516101b3919061138d565b60405180910390f35b6101d660048036038101906101d1919061130d565b610586565b005b6101f260048036038101906101ed9190611455565b6105a6565b6040516101ff91906114db565b60405180910390f35b6102106105d6565b60405161021d919061125c565b60405180910390f35b610240600480360381019061023b919061130d565b610666565b60405161024d9190611365565b60405180910390f35b610270600480360381019061026b91906114f4565b610848565b60405161027d919061138d565b60405180910390f35b6060600380546102959061155f565b80601f01602080910402602001604051908101604052809291908181526020018280546102c19061155f565b801561030c5780601f106102e35761010080835404028352916020019161030c565b820191905f5260205f20905b8154815290600101906020018083116102ef57829003601f168201915b5050505050905090565b5f806103206108ca565b905061032d8185856108d1565b600191505092915050565b5f600254905090565b5f83825f73ffffffffffffffffffffffffffffffffffffffff1660055f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff161461050f575f60055f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b91d40016040518163ffffffff1660e01b8152600401602060405180830381865afa158015610479573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061049d91906115a3565b9050804210156104ac826108e3565b6040516020016104bc9190611652565b6040516020818303038152906040529061050c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610503919061125c565b60405180910390fd5b50505b61051a868686610932565b925050509392505050565b5f6008905090565b61053e6105386108ca565b82610960565b50565b5f805f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20549050919050565b610598826105926108ca565b836109df565b6105a28282610960565b5050565b6005602052805f5260405f205f915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6060600480546105e59061155f565b80601f01602080910402602001604051908101604052809291908181526020018280546106119061155f565b801561065c5780601f106106335761010080835404028352916020019161065c565b820191905f5260205f20905b81548152906001019060200180831161063f57829003601f168201915b5050505050905090565b5f33825f73ffffffffffffffffffffffffffffffffffffffff1660055f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610834575f60055f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b91d40016040518163ffffffff1660e01b8152600401602060405180830381865afa15801561079e573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906107c291906115a3565b9050804210156107d1826108e3565b6040516020016107e19190611652565b60405160208183030381529060405290610831576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610828919061125c565b60405180910390fd5b50505b61083e8585610a71565b9250505092915050565b5f60015f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2054905092915050565b5f33905090565b6108de8383836001610a93565b505050565b60606108ee82610c62565b6108f783610c9a565b61090084610cd2565b61090985610d00565b60405160200161091c94939291906116bd565b6040516020818303038152906040529050919050565b5f8061093c6108ca565b90506109498582856109df565b610954858585610d6b565b60019150509392505050565b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16036109d0575f6040517f96c6fd1e0000000000000000000000000000000000000000000000000000000081526004016109c7919061172a565b60405180910390fd5b6109db825f83610e5b565b5050565b5f6109ea8484610848565b90507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8114610a6b5781811015610a5c578281836040517ffb8f41b2000000000000000000000000000000000000000000000000000000008152600401610a5393929190611743565b60405180910390fd5b610a6a84848484035f610a93565b5b50505050565b5f80610a7b6108ca565b9050610a88818585610d6b565b600191505092915050565b5f73ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1603610b03575f6040517fe602df05000000000000000000000000000000000000000000000000000000008152600401610afa919061172a565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1603610b73575f6040517f94280d62000000000000000000000000000000000000000000000000000000008152600401610b6a919061172a565b60405180910390fd5b8160015f8673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20819055508015610c5c578273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92584604051610c53919061138d565b60405180910390a35b50505050565b6060610c936001601e6201518085610c7a91906117d2565b610c849190611802565b610c8e9190611832565b611074565b9050919050565b6060610ccb6001600c6228206f85610cb291906117d2565b610cbc9190611802565b610cc69190611832565b611074565b9050919050565b6060610cf96107b26301e1853e84610cea91906117d2565b610cf49190611832565b611074565b9050919050565b6060610d246018610e1084610d1591906117d2565b610d1f9190611802565b611074565b610d44603c8085610d3591906117d2565b610d3f9190611802565b611074565b604051602001610d559291906118af565b6040516020818303038152906040529050919050565b5f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1603610ddb575f6040517f96c6fd1e000000000000000000000000000000000000000000000000000000008152600401610dd2919061172a565b60405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603610e4b575f6040517fec442f05000000000000000000000000000000000000000000000000000000008152600401610e42919061172a565b60405180910390fd5b610e56838383610e5b565b505050565b5f73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1603610eab578060025f828254610e9f9190611832565b92505081905550610f79565b5f805f8573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2054905081811015610f34578381836040517fe450d38c000000000000000000000000000000000000000000000000000000008152600401610f2b93929190611743565b60405180910390fd5b8181035f808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2081905550505b5f73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603610fc0578060025f828254039250508190555061100a565b805f808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f82825401925050819055505b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef83604051611067919061138d565b60405180910390a3505050565b60605f82036110ba576040518060400160405280600181526020017f300000000000000000000000000000000000000000000000000000000000000081525090506111cd565b5f8290505f5b5f82146110e95780806110d2906118dd565b915050600a826110e291906117d2565b91506110c0565b5f8167ffffffffffffffff81111561110457611103611924565b5b6040519080825280601f01601f1916602001820160405280156111365781602001600182028036833780820191505090505b5090505f8290508593505b5f84146111c557600a846111559190611802565b60306111619190611832565b60f81b828261116f90611951565b9250828151811061118357611182611978565b5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff191690815f1a905350600a846111be91906117d2565b9350611141565b819450505050505b919050565b5f81519050919050565b5f82825260208201905092915050565b5f5b838110156112095780820151818401526020810190506111ee565b5f8484015250505050565b5f601f19601f8301169050919050565b5f61122e826111d2565b61123881856111dc565b93506112488185602086016111ec565b61125181611214565b840191505092915050565b5f6020820190508181035f8301526112748184611224565b905092915050565b5f80fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6112a982611280565b9050919050565b6112b98161129f565b81146112c3575f80fd5b50565b5f813590506112d4816112b0565b92915050565b5f819050919050565b6112ec816112da565b81146112f6575f80fd5b50565b5f81359050611307816112e3565b92915050565b5f80604083850312156113235761132261127c565b5b5f611330858286016112c6565b9250506020611341858286016112f9565b9150509250929050565b5f8115159050919050565b61135f8161134b565b82525050565b5f6020820190506113785f830184611356565b92915050565b611387816112da565b82525050565b5f6020820190506113a05f83018461137e565b92915050565b5f805f606084860312156113bd576113bc61127c565b5b5f6113ca868287016112c6565b93505060206113db868287016112c6565b92505060406113ec868287016112f9565b9150509250925092565b5f60ff82169050919050565b61140b816113f6565b82525050565b5f6020820190506114245f830184611402565b92915050565b5f6020828403121561143f5761143e61127c565b5b5f61144c848285016112f9565b91505092915050565b5f6020828403121561146a5761146961127c565b5b5f611477848285016112c6565b91505092915050565b5f819050919050565b5f6114a361149e61149984611280565b611480565b611280565b9050919050565b5f6114b482611489565b9050919050565b5f6114c5826114aa565b9050919050565b6114d5816114bb565b82525050565b5f6020820190506114ee5f8301846114cc565b92915050565b5f806040838503121561150a5761150961127c565b5b5f611517858286016112c6565b9250506020611528858286016112c6565b9150509250929050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b5f600282049050600182168061157657607f821691505b60208210810361158957611588611532565b5b50919050565b5f8151905061159d816112e3565b92915050565b5f602082840312156115b8576115b761127c565b5b5f6115c58482850161158f565b91505092915050565b5f81905092915050565b7f546f6b656e207472616e73666572206c6f636b656420756e74696c20000000005f82015250565b5f61160c601c836115ce565b9150611617826115d8565b601c82019050919050565b5f61162c826111d2565b61163681856115ce565b93506116468185602086016111ec565b80840191505092915050565b5f61165c82611600565b91506116688284611622565b915081905092915050565b7f20000000000000000000000000000000000000000000000000000000000000005f82015250565b5f6116a76001836115ce565b91506116b282611673565b600182019050919050565b5f6116c88287611622565b91506116d38261169b565b91506116df8286611622565b91506116ea8261169b565b91506116f68285611622565b91506117018261169b565b915061170d8284611622565b915081905095945050505050565b6117248161129f565b82525050565b5f60208201905061173d5f83018461171b565b92915050565b5f6060820190506117565f83018661171b565b611763602083018561137e565b611770604083018461137e565b949350505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6117dc826112da565b91506117e7836112da565b9250826117f7576117f6611778565b5b828204905092915050565b5f61180c826112da565b9150611817836112da565b92508261182757611826611778565b5b828206905092915050565b5f61183c826112da565b9150611847836112da565b925082820190508082111561185f5761185e6117a5565b5b92915050565b7f3a000000000000000000000000000000000000000000000000000000000000005f82015250565b5f6118996001836115ce565b91506118a482611865565b600182019050919050565b5f6118ba8285611622565b91506118c58261188d565b91506118d18284611622565b91508190509392505050565b5f6118e7826112da565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8203611919576119186117a5565b5b600182019050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b5f61195b826112da565b91505f820361196d5761196c6117a5565b5b600182039050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffdfea26469706673582212200273291222b1f7e6de95dcd963442c0c1f86fad53a6b641a7a3b0efcb6719eef64736f6c63430008150033608060405234801562000010575f80fd5b5060405162000bae38038062000bae8339818101604052810190620000369190620001ac565b60015f819055508260015f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508160025f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508060038190555050505062000205565b5f80fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f620000fc82620000d1565b9050919050565b5f6200010f82620000f0565b9050919050565b620001218162000103565b81146200012c575f80fd5b50565b5f815190506200013f8162000116565b92915050565b6200015081620000f0565b81146200015b575f80fd5b50565b5f815190506200016e8162000145565b92915050565b5f819050919050565b620001888162000174565b811462000193575f80fd5b50565b5f81519050620001a6816200017d565b92915050565b5f805f60608486031215620001c657620001c5620000cd565b5b5f620001d5868287016200012f565b9350506020620001e8868287016200015e565b9250506040620001fb8682870162000196565b9150509250925092565b61099b80620002135f395ff3fe608060405234801561000f575f80fd5b506004361061004a575f3560e01c806338af3eed1461004e57806386d1a69f1461006c578063b91d400114610076578063fc0c546a14610094575b5f80fd5b6100566100b2565b60405161006391906105fd565b60405180910390f35b6100746100d7565b005b61007e61027a565b60405161008b919061062e565b60405180910390f35b61009c610280565b6040516100a991906106a2565b60405180910390f35b60025f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6100df6102a5565b600354421015610124576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161011b90610715565b60405180910390fd5b5f60015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b815260040161017f91906105fd565b602060405180830381865afa15801561019a573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906101be9190610761565b90505f8111610202576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016101f9906107d6565b60405180910390fd5b61026f60025f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff168260015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166102f29092919063ffffffff16565b50610278610371565b565b60035481565b60015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60025f54036102e9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016102e09061083e565b60405180910390fd5b60025f81905550565b61036c838473ffffffffffffffffffffffffffffffffffffffff1663a9059cbb858560405160240161032592919061085c565b604051602081830303815290604052915060e01b6020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505061037a565b505050565b60015f81905550565b5f6103a4828473ffffffffffffffffffffffffffffffffffffffff1661040f90919063ffffffff16565b90505f8151141580156103c85750808060200190518101906103c691906108b8565b155b1561040a57826040517f5274afe700000000000000000000000000000000000000000000000000000000815260040161040191906105fd565b60405180910390fd5b505050565b606061041c83835f610424565b905092915050565b60608147101561046b57306040517fcd78605900000000000000000000000000000000000000000000000000000000815260040161046291906105fd565b60405180910390fd5b5f808573ffffffffffffffffffffffffffffffffffffffff168486604051610493919061094f565b5f6040518083038185875af1925050503d805f81146104cd576040519150601f19603f3d011682016040523d82523d5f602084013e6104d2565b606091505b50915091506104e28683836104ed565b925050509392505050565b606082610502576104fd8261057a565b610572565b5f825114801561052857505f8473ffffffffffffffffffffffffffffffffffffffff163b145b1561056a57836040517f9996b31500000000000000000000000000000000000000000000000000000000815260040161056191906105fd565b60405180910390fd5b819050610573565b5b9392505050565b5f8151111561058c5780518082602001fd5b6040517f1425ea4200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6105e7826105be565b9050919050565b6105f7816105dd565b82525050565b5f6020820190506106105f8301846105ee565b92915050565b5f819050919050565b61062881610616565b82525050565b5f6020820190506106415f83018461061f565b92915050565b5f819050919050565b5f61066a610665610660846105be565b610647565b6105be565b9050919050565b5f61067b82610650565b9050919050565b5f61068c82610671565b9050919050565b61069c81610682565b82525050565b5f6020820190506106b55f830184610693565b92915050565b5f82825260208201905092915050565b7f52656c656173652074696d65206e6f74207265616368656400000000000000005f82015250565b5f6106ff6018836106bb565b915061070a826106cb565b602082019050919050565b5f6020820190508181035f83015261072c816106f3565b9050919050565b5f80fd5b61074081610616565b811461074a575f80fd5b50565b5f8151905061075b81610737565b92915050565b5f6020828403121561077657610775610733565b5b5f6107838482850161074d565b91505092915050565b7f4e6f20746f6b656e7320746f2072656c656173650000000000000000000000005f82015250565b5f6107c06014836106bb565b91506107cb8261078c565b602082019050919050565b5f6020820190508181035f8301526107ed816107b4565b9050919050565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c005f82015250565b5f610828601f836106bb565b9150610833826107f4565b602082019050919050565b5f6020820190508181035f8301526108558161081c565b9050919050565b5f60408201905061086f5f8301856105ee565b61087c602083018461061f565b9392505050565b5f8115159050919050565b61089781610883565b81146108a1575f80fd5b50565b5f815190506108b28161088e565b92915050565b5f602082840312156108cd576108cc610733565b5b5f6108da848285016108a4565b91505092915050565b5f81519050919050565b5f81905092915050565b5f5b838110156109145780820151818401526020810190506108f9565b5f8484015250505050565b5f610929826108e3565b61093381856108ed565b93506109438185602086016108f7565b80840191505092915050565b5f61095a828461091f565b91508190509291505056fea2646970667358221220316dd1d8f6caa6ec1dca923ec1f2daeb8b7eeb6c8311fdea09dc0dd6779dfb8564736f6c63430008150033

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

44013:4476:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33447:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35739:190;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34548:99;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48283:203;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34400:83;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43371:89;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;34710:118;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43789:161;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44106:45;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;33657:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48100:175;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35278:142;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;33447:91;33492:13;33525:5;33518:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33447:91;:::o;35739:190::-;35812:4;35829:13;35845:12;:10;:12::i;:::-;35829:28;;35868:31;35877:5;35884:7;35893:5;35868:8;:31::i;:::-;35917:4;35910:11;;;35739:190;;;;:::o;34548:99::-;34600:7;34627:12;;34620:19;;34548:99;:::o;48283:203::-;48409:4;48384:6;48392;46395:1;46357:41;;:9;:17;46367:6;46357:17;;;;;;;;;;;;;;;;;;;;;;;;;:41;;;46353:258;;46411:19;46433:9;:17;46443:6;46433:17;;;;;;;;;;;;;;;;;;;;;;;;;:29;;;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46411:53;;46502:11;46483:15;:30;;46571:29;46588:11;46571:16;:29::i;:::-;46522:79;;;;;;;;:::i;:::-;;;;;;;;;;;;;46475:128;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;46400:211;46353:258;48433:45:::1;48452:6;48460:9;48471:6;48433:18;:45::i;:::-;48426:52;;48283:203:::0;;;;;;;:::o;34400:83::-;34449:5;34474:1;34467:8;;34400:83;:::o;43371:89::-;43426:26;43432:12;:10;:12::i;:::-;43446:5;43426;:26::i;:::-;43371:89;:::o;34710:118::-;34775:7;34802:9;:18;34812:7;34802:18;;;;;;;;;;;;;;;;34795:25;;34710:118;;;:::o;43789:161::-;43865:45;43881:7;43890:12;:10;:12::i;:::-;43904:5;43865:15;:45::i;:::-;43921:21;43927:7;43936:5;43921;:21::i;:::-;43789:161;;:::o;44106:45::-;;;;;;;;;;;;;;;;;;;;;;:::o;33657:95::-;33704:13;33737:7;33730:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33657:95;:::o;48100:175::-;48210:4;48181:10;48193:6;46395:1;46357:41;;:9;:17;46367:6;46357:17;;;;;;;;;;;;;;;;;;;;;;;;;:41;;;46353:258;;46411:19;46433:9;:17;46443:6;46433:17;;;;;;;;;;;;;;;;;;;;;;;;;:29;;;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46411:53;;46502:11;46483:15;:30;;46571:29;46588:11;46571:16;:29::i;:::-;46522:79;;;;;;;;:::i;:::-;;;;;;;;;;;;;46475:128;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;46400:211;46353:258;48234:33:::1;48249:9;48260:6;48234:14;:33::i;:::-;48227:40;;48100:175:::0;;;;;;:::o;35278:142::-;35358:7;35385:11;:18;35397:5;35385:18;;;;;;;;;;;;;;;:27;35404:7;35385:27;;;;;;;;;;;;;;;;35378:34;;35278:142;;;;:::o;21086:98::-;21139:7;21166:10;21159:17;;21086:98;:::o;40566:130::-;40651:37;40660:5;40667:7;40676:5;40683:4;40651:8;:37::i;:::-;40566:130;;;:::o;46626:336::-;46694:13;46788:17;46795:9;46788:6;:17::i;:::-;46829:19;46838:9;46829:8;:19::i;:::-;46872:18;46880:9;46872:7;:18::i;:::-;46914;46922:9;46914:7;:18::i;:::-;46753:194;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;46716:242;;46626:336;;;:::o;36507:249::-;36594:4;36611:15;36629:12;:10;:12::i;:::-;36611:30;;36652:37;36668:4;36674:7;36683:5;36652:15;:37::i;:::-;36700:26;36710:4;36716:2;36720:5;36700:9;:26::i;:::-;36744:4;36737:11;;;36507:249;;;;;:::o;39802:211::-;39892:1;39873:21;;:7;:21;;;39869:91;;39945:1;39918:30;;;;;;;;;;;:::i;:::-;;;;;;;;39869:91;39970:35;39978:7;39995:1;39999:5;39970:7;:35::i;:::-;39802:211;;:::o;42282:487::-;42382:24;42409:25;42419:5;42426:7;42409:9;:25::i;:::-;42382:52;;42469:17;42449:16;:37;42445:317;;42526:5;42507:16;:24;42503:132;;;42586:7;42595:16;42613:5;42559:60;;;;;;;;;;;;;:::i;:::-;;;;;;;;42503:132;42678:57;42687:5;42694:7;42722:5;42703:16;:24;42729:5;42678:8;:57::i;:::-;42445:317;42371:398;42282:487;;;:::o;35033:182::-;35102:4;35119:13;35135:12;:10;:12::i;:::-;35119:28;;35158:27;35168:5;35175:2;35179:5;35158:9;:27::i;:::-;35203:4;35196:11;;;35033:182;;;;:::o;41547:443::-;41677:1;41660:19;;:5;:19;;;41656:91;;41732:1;41703:32;;;;;;;;;;;:::i;:::-;;;;;;;;41656:91;41780:1;41761:21;;:7;:21;;;41757:92;;41834:1;41806:31;;;;;;;;;;;:::i;:::-;;;;;;;;41757:92;41889:5;41859:11;:18;41871:5;41859:18;;;;;;;;;;;;;;;:27;41878:7;41859:27;;;;;;;;;;;;;;;:35;;;;41909:9;41905:78;;;41956:7;41940:31;;41949:5;41940:31;;;41965:5;41940:31;;;;;;:::i;:::-;;;;;;;;41905:78;41547:443;;;;:::o;46966:129::-;47024:13;47053:38;47089:1;47084:2;47075:5;47063:9;:17;;;;:::i;:::-;47062:24;;;;:::i;:::-;:28;;;;:::i;:::-;47053:8;:38::i;:::-;47046:45;;46966:129;;;:::o;47099:133::-;47159:13;47188:40;47226:1;47221:2;47210:7;47198:9;:19;;;;:::i;:::-;47197:26;;;;:::i;:::-;:30;;;;:::i;:::-;47188:8;:40::i;:::-;47181:47;;47099:133;;;:::o;47236:131::-;47295:13;47324:39;47358:4;47346:8;47334:9;:20;;;;:::i;:::-;47333:29;;;;:::i;:::-;47324:8;:39::i;:::-;47317:46;;47236:131;;;:::o;47371:271::-;47430:13;47524:33;47554:2;47546:4;47534:9;:16;;;;:::i;:::-;47533:23;;;;:::i;:::-;47524:8;:33::i;:::-;47581:31;47609:2;47603;47591:9;:14;;;;:::i;:::-;47590:21;;;;:::i;:::-;47581:8;:31::i;:::-;47489:138;;;;;;;;;:::i;:::-;;;;;;;;;;;;;47452:186;;47371:271;;;:::o;37141:308::-;37241:1;37225:18;;:4;:18;;;37221:88;;37294:1;37267:30;;;;;;;;;;;:::i;:::-;;;;;;;;37221:88;37337:1;37323:16;;:2;:16;;;37319:88;;37392:1;37363:32;;;;;;;;;;;:::i;:::-;;;;;;;;37319:88;37417:24;37425:4;37431:2;37435:5;37417:7;:24::i;:::-;37141:308;;;:::o;37773:1135::-;37879:1;37863:18;;:4;:18;;;37859:552;;38017:5;38001:12;;:21;;;;;;;:::i;:::-;;;;;;;;37859:552;;;38055:19;38077:9;:15;38087:4;38077:15;;;;;;;;;;;;;;;;38055:37;;38125:5;38111:11;:19;38107:117;;;38183:4;38189:11;38202:5;38158:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;38107:117;38379:5;38365:11;:19;38347:9;:15;38357:4;38347:15;;;;;;;;;;;;;;;:37;;;;38040:371;37859:552;38441:1;38427:16;;:2;:16;;;38423:435;;38609:5;38593:12;;:21;;;;;;;;;;;38423:435;;;38826:5;38809:9;:13;38819:2;38809:13;;;;;;;;;;;;;;;;:22;;;;;;;;;;;38423:435;38890:2;38875:25;;38884:4;38875:25;;;38894:5;38875:25;;;;;;:::i;:::-;;;;;;;;37773:1135;;;:::o;47646:446::-;47699:27;47745:1;47739:2;:7;47735:42;;47759:10;;;;;;;;;;;;;;;;;;;;;47735:42;47783:9;47795:2;47783:14;;47804;47825:60;47837:1;47832;:6;47825:60;;47851:8;;;;;:::i;:::-;;;;47875:2;47870:7;;;;;:::i;:::-;;;47825:60;;;47891:17;47921:6;47911:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47891:37;;47935:9;47947:6;47935:18;;47964:2;47960:6;;47973:90;47985:1;47980;:6;47973:90;;48033:2;48029:1;:6;;;;:::i;:::-;48024:2;:11;;;;:::i;:::-;48011:26;;47999:4;48004:3;;;;:::i;:::-;;;;47999:9;;;;;;;;:::i;:::-;;;;;:38;;;;;;;;;;;48053:2;48048:7;;;;;:::i;:::-;;;47973:90;;;48083:4;48069:19;;;;;;47646:446;;;;:::o;7:99:1:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:246::-;368:1;378:113;392:6;389:1;386:13;378:113;;;477:1;472:3;468:11;462:18;458:1;453:3;449:11;442:39;414:2;411:1;407:10;402:15;;378:113;;;525:1;516:6;511:3;507:16;500:27;349:184;287:246;;;:::o;539:102::-;580:6;631:2;627:7;622:2;615:5;611:14;607:28;597:38;;539:102;;;:::o;647:377::-;735:3;763:39;796:5;763:39;:::i;:::-;818:71;882:6;877:3;818:71;:::i;:::-;811:78;;898:65;956:6;951:3;944:4;937:5;933:16;898:65;:::i;:::-;988:29;1010:6;988:29;:::i;:::-;983:3;979:39;972:46;;739:285;647:377;;;;:::o;1030:313::-;1143:4;1181:2;1170:9;1166:18;1158:26;;1230:9;1224:4;1220:20;1216:1;1205:9;1201:17;1194:47;1258:78;1331:4;1322:6;1258:78;:::i;:::-;1250:86;;1030:313;;;;:::o;1430:117::-;1539:1;1536;1529:12;1676:126;1713:7;1753:42;1746:5;1742:54;1731:65;;1676:126;;;:::o;1808:96::-;1845:7;1874:24;1892:5;1874:24;:::i;:::-;1863:35;;1808:96;;;:::o;1910:122::-;1983:24;2001:5;1983:24;:::i;:::-;1976:5;1973:35;1963:63;;2022:1;2019;2012:12;1963:63;1910:122;:::o;2038:139::-;2084:5;2122:6;2109:20;2100:29;;2138:33;2165:5;2138:33;:::i;:::-;2038:139;;;;:::o;2183:77::-;2220:7;2249:5;2238:16;;2183:77;;;:::o;2266:122::-;2339:24;2357:5;2339:24;:::i;:::-;2332:5;2329:35;2319:63;;2378:1;2375;2368:12;2319:63;2266:122;:::o;2394:139::-;2440:5;2478:6;2465:20;2456:29;;2494:33;2521:5;2494:33;:::i;:::-;2394:139;;;;:::o;2539:474::-;2607:6;2615;2664:2;2652:9;2643:7;2639:23;2635:32;2632:119;;;2670:79;;:::i;:::-;2632:119;2790:1;2815:53;2860:7;2851:6;2840:9;2836:22;2815:53;:::i;:::-;2805:63;;2761:117;2917:2;2943:53;2988:7;2979:6;2968:9;2964:22;2943:53;:::i;:::-;2933:63;;2888:118;2539:474;;;;;:::o;3019:90::-;3053:7;3096:5;3089:13;3082:21;3071:32;;3019:90;;;:::o;3115:109::-;3196:21;3211:5;3196:21;:::i;:::-;3191:3;3184:34;3115:109;;:::o;3230:210::-;3317:4;3355:2;3344:9;3340:18;3332:26;;3368:65;3430:1;3419:9;3415:17;3406:6;3368:65;:::i;:::-;3230:210;;;;:::o;3446:118::-;3533:24;3551:5;3533:24;:::i;:::-;3528:3;3521:37;3446:118;;:::o;3570:222::-;3663:4;3701:2;3690:9;3686:18;3678:26;;3714:71;3782:1;3771:9;3767:17;3758:6;3714:71;:::i;:::-;3570:222;;;;:::o;3798:619::-;3875:6;3883;3891;3940:2;3928:9;3919:7;3915:23;3911:32;3908:119;;;3946:79;;:::i;:::-;3908:119;4066:1;4091:53;4136:7;4127:6;4116:9;4112:22;4091:53;:::i;:::-;4081:63;;4037:117;4193:2;4219:53;4264:7;4255:6;4244:9;4240:22;4219:53;:::i;:::-;4209:63;;4164:118;4321:2;4347:53;4392:7;4383:6;4372:9;4368:22;4347:53;:::i;:::-;4337:63;;4292:118;3798:619;;;;;:::o;4423:86::-;4458:7;4498:4;4491:5;4487:16;4476:27;;4423:86;;;:::o;4515:112::-;4598:22;4614:5;4598:22;:::i;:::-;4593:3;4586:35;4515:112;;:::o;4633:214::-;4722:4;4760:2;4749:9;4745:18;4737:26;;4773:67;4837:1;4826:9;4822:17;4813:6;4773:67;:::i;:::-;4633:214;;;;:::o;4853:329::-;4912:6;4961:2;4949:9;4940:7;4936:23;4932:32;4929:119;;;4967:79;;:::i;:::-;4929:119;5087:1;5112:53;5157:7;5148:6;5137:9;5133:22;5112:53;:::i;:::-;5102:63;;5058:117;4853:329;;;;:::o;5188:::-;5247:6;5296:2;5284:9;5275:7;5271:23;5267:32;5264:119;;;5302:79;;:::i;:::-;5264:119;5422:1;5447:53;5492:7;5483:6;5472:9;5468:22;5447:53;:::i;:::-;5437:63;;5393:117;5188:329;;;;:::o;5523:60::-;5551:3;5572:5;5565:12;;5523:60;;;:::o;5589:142::-;5639:9;5672:53;5690:34;5699:24;5717:5;5699:24;:::i;:::-;5690:34;:::i;:::-;5672:53;:::i;:::-;5659:66;;5589:142;;;:::o;5737:126::-;5787:9;5820:37;5851:5;5820:37;:::i;:::-;5807:50;;5737:126;;;:::o;5869:142::-;5935:9;5968:37;5999:5;5968:37;:::i;:::-;5955:50;;5869:142;;;:::o;6017:163::-;6120:53;6167:5;6120:53;:::i;:::-;6115:3;6108:66;6017:163;;:::o;6186:254::-;6295:4;6333:2;6322:9;6318:18;6310:26;;6346:87;6430:1;6419:9;6415:17;6406:6;6346:87;:::i;:::-;6186:254;;;;:::o;6446:474::-;6514:6;6522;6571:2;6559:9;6550:7;6546:23;6542:32;6539:119;;;6577:79;;:::i;:::-;6539:119;6697:1;6722:53;6767:7;6758:6;6747:9;6743:22;6722:53;:::i;:::-;6712:63;;6668:117;6824:2;6850:53;6895:7;6886:6;6875:9;6871:22;6850:53;:::i;:::-;6840:63;;6795:118;6446:474;;;;;:::o;6926:180::-;6974:77;6971:1;6964:88;7071:4;7068:1;7061:15;7095:4;7092:1;7085:15;7112:320;7156:6;7193:1;7187:4;7183:12;7173:22;;7240:1;7234:4;7230:12;7261:18;7251:81;;7317:4;7309:6;7305:17;7295:27;;7251:81;7379:2;7371:6;7368:14;7348:18;7345:38;7342:84;;7398:18;;:::i;:::-;7342:84;7163:269;7112:320;;;:::o;7438:143::-;7495:5;7526:6;7520:13;7511:22;;7542:33;7569:5;7542:33;:::i;:::-;7438:143;;;;:::o;7587:351::-;7657:6;7706:2;7694:9;7685:7;7681:23;7677:32;7674:119;;;7712:79;;:::i;:::-;7674:119;7832:1;7857:64;7913:7;7904:6;7893:9;7889:22;7857:64;:::i;:::-;7847:74;;7803:128;7587:351;;;;:::o;7944:148::-;8046:11;8083:3;8068:18;;7944:148;;;;:::o;8098:178::-;8238:30;8234:1;8226:6;8222:14;8215:54;8098:178;:::o;8282:402::-;8442:3;8463:85;8545:2;8540:3;8463:85;:::i;:::-;8456:92;;8557:93;8646:3;8557:93;:::i;:::-;8675:2;8670:3;8666:12;8659:19;;8282:402;;;:::o;8690:390::-;8796:3;8824:39;8857:5;8824:39;:::i;:::-;8879:89;8961:6;8956:3;8879:89;:::i;:::-;8872:96;;8977:65;9035:6;9030:3;9023:4;9016:5;9012:16;8977:65;:::i;:::-;9067:6;9062:3;9058:16;9051:23;;8800:280;8690:390;;;;:::o;9086:541::-;9319:3;9341:148;9485:3;9341:148;:::i;:::-;9334:155;;9506:95;9597:3;9588:6;9506:95;:::i;:::-;9499:102;;9618:3;9611:10;;9086:541;;;;:::o;9633:151::-;9773:3;9769:1;9761:6;9757:14;9750:27;9633:151;:::o;9790:400::-;9950:3;9971:84;10053:1;10048:3;9971:84;:::i;:::-;9964:91;;10064:93;10153:3;10064:93;:::i;:::-;10182:1;10177:3;10173:11;10166:18;;9790:400;;;:::o;10196:1553::-;10775:3;10797:95;10888:3;10879:6;10797:95;:::i;:::-;10790:102;;10909:148;11053:3;10909:148;:::i;:::-;10902:155;;11074:95;11165:3;11156:6;11074:95;:::i;:::-;11067:102;;11186:148;11330:3;11186:148;:::i;:::-;11179:155;;11351:95;11442:3;11433:6;11351:95;:::i;:::-;11344:102;;11463:148;11607:3;11463:148;:::i;:::-;11456:155;;11628:95;11719:3;11710:6;11628:95;:::i;:::-;11621:102;;11740:3;11733:10;;10196:1553;;;;;;;:::o;11755:118::-;11842:24;11860:5;11842:24;:::i;:::-;11837:3;11830:37;11755:118;;:::o;11879:222::-;11972:4;12010:2;11999:9;11995:18;11987:26;;12023:71;12091:1;12080:9;12076:17;12067:6;12023:71;:::i;:::-;11879:222;;;;:::o;12107:442::-;12256:4;12294:2;12283:9;12279:18;12271:26;;12307:71;12375:1;12364:9;12360:17;12351:6;12307:71;:::i;:::-;12388:72;12456:2;12445:9;12441:18;12432:6;12388:72;:::i;:::-;12470;12538:2;12527:9;12523:18;12514:6;12470:72;:::i;:::-;12107:442;;;;;;:::o;12555:180::-;12603:77;12600:1;12593:88;12700:4;12697:1;12690:15;12724:4;12721:1;12714:15;12741:180;12789:77;12786:1;12779:88;12886:4;12883:1;12876:15;12910:4;12907:1;12900:15;12927:185;12967:1;12984:20;13002:1;12984:20;:::i;:::-;12979:25;;13018:20;13036:1;13018:20;:::i;:::-;13013:25;;13057:1;13047:35;;13062:18;;:::i;:::-;13047:35;13104:1;13101;13097:9;13092:14;;12927:185;;;;:::o;13118:176::-;13150:1;13167:20;13185:1;13167:20;:::i;:::-;13162:25;;13201:20;13219:1;13201:20;:::i;:::-;13196:25;;13240:1;13230:35;;13245:18;;:::i;:::-;13230:35;13286:1;13283;13279:9;13274:14;;13118:176;;;;:::o;13300:191::-;13340:3;13359:20;13377:1;13359:20;:::i;:::-;13354:25;;13393:20;13411:1;13393:20;:::i;:::-;13388:25;;13436:1;13433;13429:9;13422:16;;13457:3;13454:1;13451:10;13448:36;;;13464:18;;:::i;:::-;13448:36;13300:191;;;;:::o;13497:151::-;13637:3;13633:1;13625:6;13621:14;13614:27;13497:151;:::o;13654:400::-;13814:3;13835:84;13917:1;13912:3;13835:84;:::i;:::-;13828:91;;13928:93;14017:3;13928:93;:::i;:::-;14046:1;14041:3;14037:11;14030:18;;13654:400;;;:::o;14060:701::-;14341:3;14363:95;14454:3;14445:6;14363:95;:::i;:::-;14356:102;;14475:148;14619:3;14475:148;:::i;:::-;14468:155;;14640:95;14731:3;14722:6;14640:95;:::i;:::-;14633:102;;14752:3;14745:10;;14060:701;;;;;:::o;14767:233::-;14806:3;14829:24;14847:5;14829:24;:::i;:::-;14820:33;;14875:66;14868:5;14865:77;14862:103;;14945:18;;:::i;:::-;14862:103;14992:1;14985:5;14981:13;14974:20;;14767:233;;;:::o;15006:180::-;15054:77;15051:1;15044:88;15151:4;15148:1;15141:15;15175:4;15172:1;15165:15;15192:171;15231:3;15254:24;15272:5;15254:24;:::i;:::-;15245:33;;15300:4;15293:5;15290:15;15287:41;;15308:18;;:::i;:::-;15287:41;15355:1;15348:5;15344:13;15337:20;;15192:171;;;:::o;15369:180::-;15417:77;15414:1;15407:88;15514:4;15511:1;15504:15;15538:4;15535:1;15528:15

ipfs://316dd1d8f6caa6ec1dca923ec1f2daeb8b7eeb6c8311fdea09dc0dd6779dfb85