Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(
•    - function mulDiv(
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•    - function log2(uint256 value)
•    - function log2(uint256 value, Rounding ...
•    - function log10(uint256 value)
•    - function log10(uint256 value, Roundin ...
•    - function log256(uint256 value)
•    - function log256(uint256 value, Roundi ...
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
• library ECDSA
•    - function _throwError(RecoverError err ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes ...
•    - function tryRecover(
•    - function recover(
•    - function tryRecover(
•    - function recover(
•    - function toEthSignedMessageHash(bytes ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toTypedDataHash(bytes32 doma ...
• 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(
• library MerkleProof
•    - function verify(
•    - function verifyCalldata(
•    - function processProof(bytes32[] memor ...
•    - function processProofCalldata(bytes32 ...
•    - function multiProofVerify(
•    - function multiProofVerifyCalldata(
•    - function processMultiProof(
•    - function processMultiProofCalldata(
•    - function _hashPair(bytes32 a, bytes32 ...
•    - function _efficientHash(bytes32 a, by ...
•  contract IDO is Ownable *
•    - function setPrice(uint256 _price)
•    - function setCap(uint _cap)
•    - function setTime(uint256 _start, uint ...
•    - function setClaim(bool status)
•    - function setAITToken(address _token)
•    - function setAdmin(address _admin, boo ...
•    - function withdrawEther()
•    - function withdrawToken(address _token ...
•    - function buy(bytes32[] memory proof, ...
•    - function released(address _user)
•    - function releasable(address _user)
•    - function release()
•    - function getMessageHash(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-12-12
*/

// Sources flattened with hardhat v2.19.1 https://hardhat.org

// SPDX-License-Identifier: MIT

// File @openzeppelin/contracts/utils/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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


// File @openzeppelin/contracts/access/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


// File @openzeppelin/contracts/utils/math/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}


// File @openzeppelin/contracts/utils/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}


// File @openzeppelin/contracts/utils/cryptography/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @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 amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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


// File @openzeppelin/contracts/utils/cryptography/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}


// File contracts/IDO.sol

// Original license: SPDX_License_Identifier: MIT
pragma solidity ^0.8.0;




contract IDO is Ownable {
    bytes32 public merkleRoot;
    address public ait;
    uint256 public aitPerEther = 147500;
    uint256 public startTime;
    uint256 public endTime;
    uint256 public cap = 140 ether;
    uint256 public total;
    bool public isClaimed;

    mapping (address => uint256) public payAmount;
    mapping (address => uint256) private aitReleased;
    mapping(address => bool) public admin;
    mapping(bytes => bool) public usedSignatures;

    modifier verifyTransactionAmount(uint _amount, uint purchaseLimit){
        require(total + _amount <= cap, "IDO: AMOUNT_WRONG");
        require(payAmount[msg.sender] + _amount <= purchaseLimit, "IDO: PURCHASE_LIMIT_WRONG");
        _;
    }

    constructor(bytes32 _merkleRoot, uint256 _start, uint256 _end) {
        merkleRoot = _merkleRoot;
        startTime = _start;
        endTime = _end;
    }

    receive() external payable {}

    event SetPrice(uint256 price, uint256 blockTime);
    event SetTime(uint256 startTime, uint256 endTime, uint256 blockTime);
    event SetCap(uint256 cap, uint256 blockTime);
    event SetClaim(bool status, uint256 blockTime);
    event SetPurchaseLimit(uint256 limit, uint256 blockTime);
    event SetAITToken(address token, uint256 blockTime);
    event SetAdmin(address admin, bool status, uint blockTime);
    event Buy(address user, uint256 amount, uint256 total, uint256 blockTime);
    event AITReleased(address user, uint256 amount, uint256 blockTime);

    function setPrice(uint256 _price) external onlyOwner {
        require(block.timestamp < startTime, "IDO has started, the price cannot be changed");
        aitPerEther = _price;
        emit SetPrice(_price, block.timestamp);
    }

    function setCap(uint _cap) external onlyOwner {
        require(block.timestamp < endTime, "IDO: CAP_WRONG");
        cap = _cap;
        emit SetCap(_cap, block.timestamp);
    }

    function setTime(uint256 _start, uint256 _end) external onlyOwner {
        if(startTime > 0) {
            require(block.timestamp < startTime);
        }
        startTime = _start;
        endTime = _end;
        emit SetTime(_start, _end, block.timestamp);
    }

    function setClaim(bool status) external onlyOwner {
        isClaimed = status;
        emit SetClaim(status, block.timestamp);
    }

    function setAITToken(address _token) external onlyOwner {
        ait = _token;
        emit SetAITToken(_token, block.timestamp);
    }

    function setAdmin(address _admin, bool _status) external onlyOwner {
        admin[_admin] =  _status;
        emit SetAdmin(_admin, _status, block.timestamp);
    }

    function withdrawEther() external onlyOwner {
        require(block.timestamp >= endTime, "The owner can only withdraw ETH after the IDO ends");
        (bool success, ) = msg.sender.call{value: address(this).balance}("");
        require(success, "Transfer failed.");
    }

    function withdrawToken(address _token) external onlyOwner {
        require(block.timestamp >= endTime, "The owner can only withdraw ETH after the IDO ends");
        uint256 amount = IERC20(_token).balanceOf(address(this));
        IERC20(_token).transfer(msg.sender, amount);
    }

    // Function to add an address to the whitelist using MerkleProof
    function buy(bytes32[] memory proof, uint256 purchaseLimit, bytes calldata signature, uint256 blockTime) external payable verifyTransactionAmount(msg.value, purchaseLimit) {
        require(!usedSignatures[signature], "IDO: signature used.");
        require(block.timestamp > startTime && block.timestamp < endTime, "IDO: TIME_WRONG");
        bytes32 leaf = keccak256(abi.encodePacked(msg.sender, purchaseLimit));
        require(MerkleProof.verify(proof, merkleRoot, leaf), "Invalid Merkle proof");
        bytes32 criteriaMessageHash = getMessageHash(msg.sender, msg.value, blockTime);
        bytes32 ethSignedMessageHash = ECDSA.toEthSignedMessageHash(criteriaMessageHash);
        require(admin[ECDSA.recover(ethSignedMessageHash, signature)],"IDO: invalid signature");
        usedSignatures[signature] = true;
        uint256 amount = msg.value;
        payAmount[msg.sender] += amount;
        total += amount;
        emit Buy(msg.sender, amount, total, block.timestamp);
    }

    function released(address _user) public view returns(uint256){
        //withdraw
        return aitReleased[_user];
    }

    function releasable(address _user) public view returns(uint256){
        //available
        uint256 amount = (block.timestamp > endTime) ? payAmount[_user] * aitPerEther : 0;
        return amount - released(_user);
    }

    function release() external {
        require(isClaimed, "IDO: IS_CLAIMED_WRONG");
        require(block.timestamp > endTime, "IDO: RELEASE_WRONG");
        uint256 amount = releasable(msg.sender);
        require(amount > 0, "IDO: AMOUNT=0");
        aitReleased[msg.sender] += amount;
        emit AITReleased(msg.sender, amount, block.timestamp);
        IERC20(ait).transfer(msg.sender, amount);
    }

    function getMessageHash(
        address _user,
        uint256 amount,
        uint256 blockTime
    ) public view returns (bytes32) {
         return
            keccak256(
                abi.encodePacked(
                    _user,
                    amount,
                    blockTime
                )
            );
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"},{"internalType":"uint256","name":"_start","type":"uint256"},{"internalType":"uint256","name":"_end","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"blockTime","type":"uint256"}],"name":"AITReleased","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"total","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"blockTime","type":"uint256"}],"name":"Buy","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"blockTime","type":"uint256"}],"name":"SetAITToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"admin","type":"address"},{"indexed":false,"internalType":"bool","name":"status","type":"bool"},{"indexed":false,"internalType":"uint256","name":"blockTime","type":"uint256"}],"name":"SetAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"cap","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"blockTime","type":"uint256"}],"name":"SetCap","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"status","type":"bool"},{"indexed":false,"internalType":"uint256","name":"blockTime","type":"uint256"}],"name":"SetClaim","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"price","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"blockTime","type":"uint256"}],"name":"SetPrice","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"limit","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"blockTime","type":"uint256"}],"name":"SetPurchaseLimit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"startTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"endTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"blockTime","type":"uint256"}],"name":"SetTime","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"admin","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ait","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"aitPerEther","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"uint256","name":"purchaseLimit","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint256","name":"blockTime","type":"uint256"}],"name":"buy","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"endTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"blockTime","type":"uint256"}],"name":"getMessageHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"payAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"releasable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"setAITToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_admin","type":"address"},{"internalType":"bool","name":"_status","type":"bool"}],"name":"setAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cap","type":"uint256"}],"name":"setCap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"status","type":"bool"}],"name":"setClaim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_start","type":"uint256"},{"internalType":"uint256","name":"_end","type":"uint256"}],"name":"setTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"total","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"","type":"bytes"}],"name":"usedSignatures","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawEther","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"withdrawToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0ef093b522b77b928bbd7c540d81f173b8149535923b25f0a79f8ea75053d3c60000000000000000000000000000000000000000000000000000000065787570000000000000000000000000000000000000000000000000000000006579c6f0

-----Decoded View---------------
Arg [0] : _merkleRoot (bytes32): 0x0ef093b522b77b928bbd7c540d81f173b8149535923b25f0a79f8ea75053d3c6
Arg [1] : _start (uint256): 1702393200
Arg [2] : _end (uint256): 1702479600

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0ef093b522b77b928bbd7c540d81f173b8149535923b25f0a79f8ea75053d3c6
Arg [1] : 0000000000000000000000000000000000000000000000000000000065787570
Arg [2] : 000000000000000000000000000000000000000000000000000000006579c6f0

40599:5501:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42837:136;;;;;;;;;;-1:-1:-1;42837:136:0;;;;;:::i;:::-;;:::i;:::-;;42981:139;;;;;;;;;;-1:-1:-1;42981:139:0;;;;;:::i;:::-;;:::i;40826:20::-;;;;;;;;;;;;;;;;;;;898:25:1;;;886:2;871:18;40826:20:0;;;;;;;;40630:25;;;;;;;;;;;;;;;;40760:22;;;;;;;;;;;;;;;;40789:30;;;;;;;;;;;;;;;;42365:183;;;;;;;;;;-1:-1:-1;42365:183:0;;;;;:::i;:::-;;:::i;43128:168::-;;;;;;;;;;-1:-1:-1;43128:168:0;;;;;:::i;:::-;;:::i;40853:21::-;;;;;;;;;;-1:-1:-1;40853:21:0;;;;;;;;;;;1786:14:1;;1779:22;1761:41;;1749:2;1734:18;40853:21:0;1621:187:1;40990:37:0;;;;;;;;;;-1:-1:-1;40990:37:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;40662:18;;;;;;;;;;-1:-1:-1;40662:18:0;;;;-1:-1:-1;;;;;40662:18:0;;;;;;-1:-1:-1;;;;;1977:32:1;;;1959:51;;1947:2;1932:18;40662::0;1813:203:1;2986:103:0;;;;;;;;;;;;;:::i;43304:278::-;;;;;;;;;;;;;:::i;40729:24::-;;;;;;;;;;;;;;;;45331:413;;;;;;;;;;;;;:::i;43590:287::-;;;;;;;;;;-1:-1:-1;43590:287:0;;;;;:::i;:::-;;:::i;2338:87::-;;;;;;;;;;-1:-1:-1;2384:7:0;2411:6;-1:-1:-1;;;;;2411:6:0;2338:87;;42121:236;;;;;;;;;;-1:-1:-1;42121:236:0;;;;;:::i;:::-;;:::i;44964:125::-;;;;;;;;;;-1:-1:-1;44964:125:0;;;;;:::i;:::-;-1:-1:-1;;;;;45063:18:0;45017:7;45063:18;;;:11;:18;;;;;;;44964:125;42556:273;;;;;;;;;;-1:-1:-1;42556:273:0;;;;;:::i;:::-;;:::i;45097:226::-;;;;;;;;;;-1:-1:-1;45097:226:0;;;;;:::i;:::-;;:::i;45752:345::-;;;;;;;;;;-1:-1:-1;45752:345:0;;;;;:::i;:::-;;:::i;40687:35::-;;;;;;;;;;;;;;;;41034:44;;;;;;;;;;-1:-1:-1;41034:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3244:201;;;;;;;;;;-1:-1:-1;3244:201:0;;;;;:::i;:::-;;:::i;40883:45::-;;;;;;;;;;-1:-1:-1;40883:45:0;;;;;:::i;:::-;;;;;;;;;;;;;;43955:1001;;;;;;:::i;:::-;;:::i;42837:136::-;2224:13;:11;:13::i;:::-;42898:9:::1;:18:::0;;-1:-1:-1;;42898:18:0::1;::::0;::::1;;::::0;;::::1;::::0;;;42932:33:::1;::::0;;5678:41:1;;;42949:15:0::1;5750:2:1::0;5735:18;;5728:34;42932:33:0::1;::::0;5651:18:1;42932:33:0::1;;;;;;;;42837:136:::0;:::o;42981:139::-;2224:13;:11;:13::i;:::-;43048:3:::1;:12:::0;;-1:-1:-1;;;;;;43048:12:0::1;-1:-1:-1::0;;;;;43048:12:0;::::1;::::0;;::::1;::::0;;;43076:36:::1;::::0;;5947:51:1;;;43096:15:0::1;6029:2:1::0;6014:18;;6007:34;43076:36:0::1;::::0;5920:18:1;43076:36:0::1;5773:274:1::0;42365:183:0;2224:13;:11;:13::i;:::-;42448:7:::1;;42430:15;:25;42422:52;;;::::0;-1:-1:-1;;;42422:52:0;;6254:2:1;42422:52:0::1;::::0;::::1;6236:21:1::0;6293:2;6273:18;;;6266:30;-1:-1:-1;;;6312:18:1;;;6305:44;6366:18;;42422:52:0::1;;;;;;;;;42485:3;:10:::0;;;42511:29:::1;::::0;;6569:25:1;;;42524:15:0::1;6625:2:1::0;6610:18;;6603:34;42511:29:0::1;::::0;6542:18:1;42511:29:0::1;6395:248:1::0;43128:168:0;2224:13;:11;:13::i;:::-;-1:-1:-1;;;;;43206:13:0;::::1;;::::0;;;:5:::1;:13;::::0;;;;;;;;:24;;-1:-1:-1;;43206:24:0::1;::::0;::::1;;::::0;;::::1;::::0;;;43246:42;;6844:51:1;;;6911:18;;;6904:50;43272:15:0::1;6970:18:1::0;;;6963:34;43246:42:0::1;::::0;6832:2:1;6817:18;43246:42:0::1;;;;;;;;43128:168:::0;;:::o;2986:103::-;2224:13;:11;:13::i;:::-;3051:30:::1;3078:1;3051:18;:30::i;:::-;2986:103::o:0;43304:278::-;2224:13;:11;:13::i;:::-;43386:7:::1;;43367:15;:26;;43359:89;;;;-1:-1:-1::0;;;43359:89:0::1;;;;;;;:::i;:::-;43478:49;::::0;43460:12:::1;::::0;43478:10:::1;::::0;43501:21:::1;::::0;43460:12;43478:49;43460:12;43478:49;43501:21;43478:10;:49:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43459:68;;;43546:7;43538:36;;;::::0;-1:-1:-1;;;43538:36:0;;7839:2:1;43538:36:0::1;::::0;::::1;7821:21:1::0;7878:2;7858:18;;;7851:30;-1:-1:-1;;;7897:18:1;;;7890:46;7953:18;;43538:36:0::1;7637:340:1::0;43538:36:0::1;43348:234;43304:278::o:0;45331:413::-;45378:9;;;;45370:43;;;;-1:-1:-1;;;45370:43:0;;8184:2:1;45370:43:0;;;8166:21:1;8223:2;8203:18;;;8196:30;-1:-1:-1;;;8242:18:1;;;8235:51;8303:18;;45370:43:0;7982:345:1;45370:43:0;45450:7;;45432:15;:25;45424:56;;;;-1:-1:-1;;;45424:56:0;;8534:2:1;45424:56:0;;;8516:21:1;8573:2;8553:18;;;8546:30;-1:-1:-1;;;8592:18:1;;;8585:48;8650:18;;45424:56:0;8332:342:1;45424:56:0;45491:14;45508:22;45519:10;45508;:22::i;:::-;45491:39;;45558:1;45549:6;:10;45541:36;;;;-1:-1:-1;;;45541:36:0;;8881:2:1;45541:36:0;;;8863:21:1;8920:2;8900:18;;;8893:30;-1:-1:-1;;;8939:18:1;;;8932:43;8992:18;;45541:36:0;8679:337:1;45541:36:0;45600:10;45588:23;;;;:11;:23;;;;;:33;;45615:6;;45588:23;:33;;45615:6;;45588:33;:::i;:::-;;;;-1:-1:-1;;45637:48:0;;;45649:10;9488:51:1;;9570:2;9555:18;;9548:34;;;45669:15:0;9598:18:1;;;9591:34;45637:48:0;;;;;;;9476:2:1;45637:48:0;;;45703:3;;45696:40;;-1:-1:-1;;;45696:40:0;;45717:10;45696:40;;;5947:51:1;6014:18;;;6007:34;;;-1:-1:-1;;;;;45703:3:0;;;;45696:20;;5920:18:1;;45696:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;45359:385;45331:413::o;43590:287::-;2224:13;:11;:13::i;:::-;43686:7:::1;;43667:15;:26;;43659:89;;;;-1:-1:-1::0;;;43659:89:0::1;;;;;;;:::i;:::-;43776:39;::::0;-1:-1:-1;;;43776:39:0;;43809:4:::1;43776:39;::::0;::::1;1959:51:1::0;43759:14:0::1;::::0;-1:-1:-1;;;;;43776:24:0;::::1;::::0;::::1;::::0;1932:18:1;;43776:39:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;43826:43;::::0;-1:-1:-1;;;43826:43:0;;43850:10:::1;43826:43;::::0;::::1;5947:51:1::0;6014:18;;;6007:34;;;43759:56:0;;-1:-1:-1;;;;;;43826:23:0;::::1;::::0;::::1;::::0;5920:18:1;;43826:43:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;43648:229;43590:287:::0;:::o;42121:236::-;2224:13;:11;:13::i;:::-;42211:9:::1;;42193:15;:27;42185:84;;;::::0;-1:-1:-1;;;42185:84:0;;10277:2:1;42185:84:0::1;::::0;::::1;10259:21:1::0;10316:2;10296:18;;;10289:30;10355:34;10335:18;;;10328:62;-1:-1:-1;;;10406:18:1;;;10399:42;10458:19;;42185:84:0::1;10075:408:1::0;42185:84:0::1;42280:11;:20:::0;;;42316:33:::1;::::0;;6569:25:1;;;42333:15:0::1;6625:2:1::0;6610:18;;6603:34;42316:33:0::1;::::0;6542:18:1;42316:33:0::1;6395:248:1::0;42556:273:0;2224:13;:11;:13::i;:::-;42636:9:::1;::::0;:13;42633:81:::1;;42692:9;;42674:15;:27;42666:36;;;::::0;::::1;;42724:9;:18:::0;;;42753:7:::1;:14:::0;;;42783:38:::1;::::0;;10690:25:1;;;10746:2;10731:18;;10724:34;;;42805:15:0::1;10774:18:1::0;;;10767:34;;;;42783:38:0::1;::::0;10678:2:1;10663:18;42783:38:0::1;10488:319:1::0;45097:226:0;45152:7;45192:14;45228:7;;45210:15;:25;45209:64;;45272:1;45209:64;;;45258:11;;-1:-1:-1;;;;;45239:16:0;;;;;;:9;:16;;;;;;:30;;45258:11;45239:30;:::i;:::-;45192:81;;45300:15;45309:5;-1:-1:-1;;;;;45063:18:0;45017:7;45063:18;;;:11;:18;;;;;;;44964:125;45300:15;45291:24;;:6;:24;:::i;:::-;45284:31;45097:226;-1:-1:-1;;;45097:226:0:o;45752:345::-;45950:124;;-1:-1:-1;;11320:2:1;11316:15;;;11312:53;45950:124:0;;;11300:66:1;11382:12;;;11375:28;;;11419:12;;;11412:28;;;45881:7:0;;11456:12:1;;45950:124:0;;;;;;;;;;;;45922:167;;;;;;45902:187;;45752:345;;;;;:::o;3244:201::-;2224:13;:11;:13::i;:::-;-1:-1:-1;;;;;3333:22:0;::::1;3325:73;;;::::0;-1:-1:-1;;;3325:73:0;;11681:2:1;3325:73:0::1;::::0;::::1;11663:21:1::0;11720:2;11700:18;;;11693:30;11759:34;11739:18;;;11732:62;-1:-1:-1;;;11810:18:1;;;11803:36;11856:19;;3325:73:0::1;11479:402:1::0;3325:73:0::1;3409:28;3428:8;3409:18;:28::i;43955:1001::-:0;44101:9;44112:13;41191:3;;41180:7;41172:5;;:15;;;;:::i;:::-;:22;;41164:52;;;;-1:-1:-1;;;41164:52:0;;12088:2:1;41164:52:0;;;12070:21:1;12127:2;12107:18;;;12100:30;-1:-1:-1;;;12146:18:1;;;12139:47;12203:18;;41164:52:0;11886:341:1;41164:52:0;41245:10;41235:21;;;;:9;:21;;;;;;41270:13;;41235:31;;41259:7;;41235:31;:::i;:::-;:48;;41227:86;;;;-1:-1:-1;;;41227:86:0;;12434:2:1;41227:86:0;;;12416:21:1;12473:2;12453:18;;;12446:30;12512:27;12492:18;;;12485:55;12557:18;;41227:86:0;12232:349:1;41227:86:0;44147:14:::1;44162:9;;44147:25;;;;;;;:::i;:::-;::::0;;;::::1;::::0;;;;;::::1;::::0;;;;::::1;;44146:26;44138:59;;;::::0;-1:-1:-1;;;44138:59:0;;13064:2:1;44138:59:0::1;::::0;::::1;13046:21:1::0;13103:2;13083:18;;;13076:30;-1:-1:-1;;;13122:18:1;;;13115:50;13182:18;;44138:59:0::1;12862:344:1::0;44138:59:0::1;44234:9;;44216:15;:27;:56;;;;;44265:7;;44247:15;:25;44216:56;44208:84;;;::::0;-1:-1:-1;;;44208:84:0;;13413:2:1;44208:84:0::1;::::0;::::1;13395:21:1::0;13452:2;13432:18;;;13425:30;-1:-1:-1;;;13471:18:1;;;13464:45;13526:18;;44208:84:0::1;13211:339:1::0;44208:84:0::1;44328:43;::::0;-1:-1:-1;;44345:10:0::1;13732:2:1::0;13728:15;13724:53;44328:43:0::1;::::0;::::1;13712:66:1::0;13794:12;;;13787:28;;;44303:12:0::1;::::0;13831::1;;44328:43:0::1;;;;;;;;;;;;44318:54;;;;;;44303:69;;44391:43;44410:5;44417:10;;44429:4;44391:18;:43::i;:::-;44383:76;;;::::0;-1:-1:-1;;;44383:76:0;;14056:2:1;44383:76:0::1;::::0;::::1;14038:21:1::0;14095:2;14075:18;;;14068:30;-1:-1:-1;;;14114:18:1;;;14107:50;14174:18;;44383:76:0::1;13854:344:1::0;44383:76:0::1;44470:27;44500:48;44515:10;44527:9;44538;44500:14;:48::i;:::-;44470:78;;44559:28;44590:49;44619:19;26817:58:::0;;15579:66:1;26817:58:0;;;15567:79:1;15662:12;;;15655:28;;;26684:7:0;;15699:12:1;;26817:58:0;;;;;;;;;;;;26807:69;;;;;;26800:76;;26615:269;;;;44590:49:::1;44559:80;;44658:5;:53;44664:46;44678:20;44700:9;;44664:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;44664:13:0::1;::::0;-1:-1:-1;;;44664:46:0:i:1;:::-;-1:-1:-1::0;;;;;44658:53:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;44658:53:0;;::::1;;44650:87;;;::::0;-1:-1:-1;;;44650:87:0;;14405:2:1;44650:87:0::1;::::0;::::1;14387:21:1::0;14444:2;14424:18;;;14417:30;-1:-1:-1;;;14463:18:1;;;14456:52;14525:18;;44650:87:0::1;14203:346:1::0;44650:87:0::1;44776:4;44748:14;44763:9;;44748:25;;;;;;;:::i;:::-;::::0;;;::::1;::::0;;::::1;::::0;;;;;;;;:32;;-1:-1:-1;;44748:32:0::1;::::0;::::1;;::::0;;;::::1;::::0;;;44838:10:::1;-1:-1:-1::0;44828:21:0;;;:9:::1;:21:::0;;;;;;:31;;44808:9:::1;::::0;;;44828:21;:31:::1;::::0;44808:9;;44828:31:::1;:::i;:::-;;;;;;;;44879:6;44870:5;;:15;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;44925:5:0::1;::::0;44901:47:::1;::::0;;44905:10:::1;14785:51:1::0;;14867:2;14852:18;;14845:34;;;14895:18;;;14888:34;;;;44932:15:0::1;14953:2:1::0;14938:18;;14931:34;44901:47:0;::::1;::::0;;;;14772:3:1;44901:47:0;;::::1;44127:829;;;;43955:1001:::0;;;;;;;:::o;2503:132::-;2384:7;2411:6;-1:-1:-1;;;;;2411:6:0;914:10;2567:23;2559:68;;;;-1:-1:-1;;;2559:68:0;;15178:2:1;2559:68:0;;;15160:21:1;;;15197:18;;;15190:30;15256:34;15236:18;;;15229:62;15308:18;;2559:68:0;14976:356:1;3605:191:0;3679:16;3698:6;;-1:-1:-1;;;;;3715:17:0;;;-1:-1:-1;;;;;;3715:17:0;;;;;;3748:40;;3698:6;;;;;;;3748:40;;3679:16;3748:40;3668:128;3605:191;:::o;32145:190::-;32270:4;32323;32294:25;32307:5;32314:4;32294:12;:25::i;:::-;:33;;32145:190;-1:-1:-1;;;;32145:190:0:o;22925:231::-;23003:7;23024:17;23043:18;23065:27;23076:4;23082:9;23065:10;:27::i;:::-;23023:69;;;;23103:18;23115:5;23103:11;:18::i;:::-;-1:-1:-1;23139:9:0;22925:231;-1:-1:-1;;;22925:231:0:o;33012:296::-;33095:7;33138:4;33095:7;33153:118;33177:5;:12;33173:1;:16;33153:118;;;33226:33;33236:12;33250:5;33256:1;33250:8;;;;;;;;:::i;:::-;;;;;;;33226:9;:33::i;:::-;33211:48;-1:-1:-1;33191:3:0;;;;:::i;:::-;;;;33153:118;;21376:747;21457:7;21466:12;21495:9;:16;21515:2;21495:22;21491:625;;;21839:4;21824:20;;21818:27;21889:4;21874:20;;21868:27;21947:4;21932:20;;21926:27;21534:9;21918:36;21990:25;22001:4;21918:36;21818:27;21868;21990:10;:25::i;:::-;21983:32;;;;;;;;;21491:625;-1:-1:-1;22064:1:0;;-1:-1:-1;22068:35:0;21491:625;21376:747;;;;;:::o;19769:521::-;19847:20;19838:5;:29;;;;;;;;:::i;:::-;;19834:449;;;19769:521;:::o;19834:449::-;19945:29;19936:5;:38;;;;;;;;:::i;:::-;;19932:351;;;19991:34;;-1:-1:-1;;;19991:34:0;;16328:2:1;19991:34:0;;;16310:21:1;16367:2;16347:18;;;16340:30;16406:26;16386:18;;;16379:54;16450:18;;19991:34:0;16126:348:1;19932:351:0;20056:35;20047:5;:44;;;;;;;;:::i;:::-;;20043:240;;;20108:41;;-1:-1:-1;;;20108:41:0;;16681:2:1;20108:41:0;;;16663:21:1;16720:2;16700:18;;;16693:30;16759:33;16739:18;;;16732:61;16810:18;;20108:41:0;16479:355:1;20043:240:0;20180:30;20171:5;:39;;;;;;;;:::i;:::-;;20167:116;;;20227:44;;-1:-1:-1;;;20227:44:0;;17041:2:1;20227:44:0;;;17023:21:1;17080:2;17060:18;;;17053:30;17119:34;17099:18;;;17092:62;-1:-1:-1;;;17170:18:1;;;17163:32;17212:19;;20227:44:0;16839:398:1;40052:149:0;40115:7;40146:1;40142;:5;:51;;40277:13;40371:15;;;40407:4;40400:15;;;40454:4;40438:21;;40142:51;;;-1:-1:-1;40277:13:0;40371:15;;;40407:4;40400:15;40454:4;40438:21;;;40052:149::o;24377:1520::-;24508:7;;25442:66;25429:79;;25425:163;;;-1:-1:-1;25541:1:0;;-1:-1:-1;25545:30:0;25525:51;;25425:163;25702:24;;;25685:14;25702:24;;;;;;;;;17469:25:1;;;17542:4;17530:17;;17510:18;;;17503:45;;;;17564:18;;;17557:34;;;17607:18;;;17600:34;;;25702:24:0;;17441:19:1;;25702:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;25702:24:0;;-1:-1:-1;;25702:24:0;;;-1:-1:-1;;;;;;;25741:20:0;;25737:103;;25794:1;25798:29;25778:50;;;;;;;25737:103;25860:6;-1:-1:-1;25868:20:0;;-1:-1:-1;24377:1520:0;;;;;;;;:::o;14:118:1:-;100:5;93:13;86:21;79:5;76:32;66:60;;122:1;119;112:12;137:241;193:6;246:2;234:9;225:7;221:23;217:32;214:52;;;262:1;259;252:12;214:52;301:9;288:23;320:28;342:5;320:28;:::i;383:173::-;451:20;;-1:-1:-1;;;;;500:31:1;;490:42;;480:70;;546:1;543;536:12;480:70;383:173;;;:::o;561:186::-;620:6;673:2;661:9;652:7;648:23;644:32;641:52;;;689:1;686;679:12;641:52;712:29;731:9;712:29;:::i;1116:180::-;1175:6;1228:2;1216:9;1207:7;1203:23;1199:32;1196:52;;;1244:1;1241;1234:12;1196:52;-1:-1:-1;1267:23:1;;1116:180;-1:-1:-1;1116:180:1:o;1301:315::-;1366:6;1374;1427:2;1415:9;1406:7;1402:23;1398:32;1395:52;;;1443:1;1440;1433:12;1395:52;1466:29;1485:9;1466:29;:::i;:::-;1456:39;;1545:2;1534:9;1530:18;1517:32;1558:28;1580:5;1558:28;:::i;:::-;1605:5;1595:15;;;1301:315;;;;;:::o;2021:248::-;2089:6;2097;2150:2;2138:9;2129:7;2125:23;2121:32;2118:52;;;2166:1;2163;2156:12;2118:52;-1:-1:-1;;2189:23:1;;;2259:2;2244:18;;;2231:32;;-1:-1:-1;2021:248:1:o;2274:322::-;2351:6;2359;2367;2420:2;2408:9;2399:7;2395:23;2391:32;2388:52;;;2436:1;2433;2426:12;2388:52;2459:29;2478:9;2459:29;:::i;:::-;2449:39;2535:2;2520:18;;2507:32;;-1:-1:-1;2586:2:1;2571:18;;;2558:32;;2274:322;-1:-1:-1;;;2274:322:1:o;2601:127::-;2662:10;2657:3;2653:20;2650:1;2643:31;2693:4;2690:1;2683:15;2717:4;2714:1;2707:15;2733:275;2804:2;2798:9;2869:2;2850:13;;-1:-1:-1;;2846:27:1;2834:40;;2904:18;2889:34;;2925:22;;;2886:62;2883:88;;;2951:18;;:::i;:::-;2987:2;2980:22;2733:275;;-1:-1:-1;2733:275:1:o;3013:763::-;3081:6;3112:2;3155;3143:9;3134:7;3130:23;3126:32;3123:52;;;3171:1;3168;3161:12;3123:52;3211:9;3198:23;3240:18;3281:2;3273:6;3270:14;3267:34;;;3297:1;3294;3287:12;3267:34;3335:6;3324:9;3320:22;3310:32;;3380:7;3373:4;3369:2;3365:13;3361:27;3351:55;;3402:1;3399;3392:12;3351:55;3438:2;3425:16;3460:2;3456;3453:10;3450:36;;;3466:18;;:::i;:::-;3508:53;3551:2;3532:13;;-1:-1:-1;;3528:27:1;3524:36;;3508:53;:::i;:::-;3495:66;;3584:2;3577:5;3570:17;3624:7;3619:2;3614;3610;3606:11;3602:20;3599:33;3596:53;;;3645:1;3642;3635:12;3596:53;3700:2;3695;3691;3687:11;3682:2;3675:5;3671:14;3658:45;3744:1;3723:14;;;3719:23;;;3712:34;;;;-1:-1:-1;3727:5:1;3013:763;-1:-1:-1;;;3013:763:1:o;3781:347::-;3832:8;3842:6;3896:3;3889:4;3881:6;3877:17;3873:27;3863:55;;3914:1;3911;3904:12;3863:55;-1:-1:-1;3937:20:1;;3980:18;3969:30;;3966:50;;;4012:1;4009;4002:12;3966:50;4049:4;4041:6;4037:17;4025:29;;4101:3;4094:4;4085:6;4077;4073:19;4069:30;4066:39;4063:59;;;4118:1;4115;4108:12;4133:1372;4255:6;4263;4271;4279;4287;4340:3;4328:9;4319:7;4315:23;4311:33;4308:53;;;4357:1;4354;4347:12;4308:53;4397:9;4384:23;4426:18;4467:2;4459:6;4456:14;4453:34;;;4483:1;4480;4473:12;4453:34;4521:6;4510:9;4506:22;4496:32;;4566:7;4559:4;4555:2;4551:13;4547:27;4537:55;;4588:1;4585;4578:12;4537:55;4624:2;4611:16;4646:4;4669:2;4665;4662:10;4659:36;;;4675:18;;:::i;:::-;4721:2;4718:1;4714:10;4744:28;4768:2;4764;4760:11;4744:28;:::i;:::-;4806:15;;;4876:11;;;4872:20;;;4837:12;;;;4904:19;;;4901:39;;;4936:1;4933;4926:12;4901:39;4960:11;;;;4980:142;4996:6;4991:3;4988:15;4980:142;;;5062:17;;5050:30;;5013:12;;;;5100;;;;4980:142;;;5141:5;-1:-1:-1;;;5178:18:1;;5165:32;;-1:-1:-1;;5250:2:1;5235:18;;5222:32;;-1:-1:-1;5266:16:1;;;5263:36;;;5295:1;5292;5285:12;5263:36;;5334:60;5386:7;5375:8;5364:9;5360:24;5334:60;:::i;:::-;4133:1372;;;;-1:-1:-1;5413:8:1;5495:2;5480:18;5467:32;;4133:1372;-1:-1:-1;;;;4133:1372:1:o;7008:414::-;7210:2;7192:21;;;7249:2;7229:18;;;7222:30;7288:34;7283:2;7268:18;;7261:62;-1:-1:-1;;;7354:2:1;7339:18;;7332:48;7412:3;7397:19;;7008:414::o;9021:127::-;9082:10;9077:3;9073:20;9070:1;9063:31;9113:4;9110:1;9103:15;9137:4;9134:1;9127:15;9153:128;9193:3;9224:1;9220:6;9217:1;9214:13;9211:39;;;9230:18;;:::i;:::-;-1:-1:-1;9266:9:1;;9153:128::o;9636:245::-;9703:6;9756:2;9744:9;9735:7;9731:23;9727:32;9724:52;;;9772:1;9769;9762:12;9724:52;9804:9;9798:16;9823:28;9845:5;9823:28;:::i;9886:184::-;9956:6;10009:2;9997:9;9988:7;9984:23;9980:32;9977:52;;;10025:1;10022;10015:12;9977:52;-1:-1:-1;10048:16:1;;9886:184;-1:-1:-1;9886:184:1:o;10812:168::-;10852:7;10918:1;10914;10910:6;10906:14;10903:1;10900:21;10895:1;10888:9;10881:17;10877:45;10874:71;;;10925:18;;:::i;:::-;-1:-1:-1;10965:9:1;;10812:168::o;10985:125::-;11025:4;11053:1;11050;11047:8;11044:34;;;11058:18;;:::i;:::-;-1:-1:-1;11095:9:1;;10985:125::o;12586:271::-;12769:6;12761;12756:3;12743:33;12725:3;12795:16;;12820:13;;;12795:16;12586:271;-1:-1:-1;12586:271:1:o;15722:127::-;15783:10;15778:3;15774:20;15771:1;15764:31;15814:4;15811:1;15804:15;15838:4;15835:1;15828:15;15854:135;15893:3;-1:-1:-1;;15914:17:1;;15911:43;;;15934:18;;:::i;:::-;-1:-1:-1;15981:1:1;15970:13;;15854:135::o;15994:127::-;16055:10;16050:3;16046:20;16043:1;16036:31;16086:4;16083:1;16076:15;16110:4;16107:1;16100:15

ipfs://08cb95a091913d739de2a7277f8c2e09936718b249f53a404bc7d7dba92196a3