Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

pragma solidity 0.8.4;

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/MerkleProof.sol)
/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 *
 * 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.
 */
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 proved to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * _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}
     *
     * _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 the sibling nodes in `proof`,
     * consuming from one or the other at each step according to the instructions given by
     * `proofFlags`.
     *
     * _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}
     *
     * _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)
        }
    }
}

// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
/**
 * @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() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
 * @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;
    }
}

// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_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) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

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

// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
/**
 * @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);
    }
}

// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)
/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(
        address indexed from,
        address indexed to,
        uint256 indexed tokenId
    );

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(
        address indexed owner,
        address indexed approved,
        uint256 indexed tokenId
    );

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(
        address indexed owner,
        address indexed operator,
        bool approved
    );

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId)
        external
        view
        returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator)
        external
        view
        returns (bool);
}

// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)
/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// ERC721A Contracts v3.3.0
// Creator: Chiru Labs
/**
 * @dev Interface of an ERC721A compliant contract.
 */
interface IERC721A is IERC721, IERC721Metadata {
    /**
     * The caller must own the token or be an approved operator.
     */
    error ApprovalCallerNotOwnerNorApproved();

    /**
     * The token does not exist.
     */
    error ApprovalQueryForNonexistentToken();

    /**
     * The caller cannot approve to their own address.
     */
    error ApproveToCaller();

    /**
     * The caller cannot approve to the current owner.
     */
    error ApprovalToCurrentOwner();

    /**
     * Cannot query the balance for the zero address.
     */
    error BalanceQueryForZeroAddress();

    /**
     * Cannot mint to the zero address.
     */
    error MintToZeroAddress();

    /**
     * The quantity of tokens minted must be more than zero.
     */
    error MintZeroQuantity();

    /**
     * The token does not exist.
     */
    error OwnerQueryForNonexistentToken();

    /**
     * The caller must own the token or be an approved operator.
     */
    error TransferCallerNotOwnerNorApproved();

    /**
     * The token must be owned by `from`.
     */
    error TransferFromIncorrectOwner();

    /**
     * Cannot safely transfer to a contract that does not implement the ERC721Receiver interface.
     */
    error TransferToNonERC721ReceiverImplementer();

    /**
     * Cannot transfer to the zero address.
     */
    error TransferToZeroAddress();

    /**
     * The token does not exist.
     */
    error URIQueryForNonexistentToken();

    // Compiler will pack this into a single 256bit word.
    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

    // Compiler will pack this into a single 256bit word.
    struct AddressData {
        // Realistically, 2**64-1 is more than enough.
        uint64 balance;
        // Keeps track of mint count with minimal overhead for tokenomics.
        uint64 numberMinted;
        // Keeps track of burn count with minimal overhead for tokenomics.
        uint64 numberBurned;
        // For miscellaneous variable(s) pertaining to the address
        // (e.g. number of whitelist mint slots used).
        // If there are multiple variables, please pack them into a uint64.
        uint64 aux;
    }

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     *
     * Burned tokens are calculated here, use `_totalMinted()` if you want to count just minted tokens.
     */
    function totalSupply() external view returns (uint256);
}

// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)
/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override
        returns (bool)
    {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// ERC721A Contracts v3.3.0
// Creator: Chiru Labs
/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is Context, ERC165, IERC721A {
    using Address for address;
    using Strings for uint256;

    // The tokenId of the next token to be minted.
    uint256 internal _currentIndex;

    // The number of tokens burned.
    uint256 internal _burnCounter;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned. See _ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

    // Mapping owner address to address data
    mapping(address => AddressData) private _addressData;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _currentIndex = _startTokenId();
    }

    /**
     * To change the starting tokenId, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
     */
    function totalSupply() public view override returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex - _startTokenId() times
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    /**
     * Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        // Counter underflow is impossible as _currentIndex does not decrement,
        // and it is initialized to _startTokenId()
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC165, IERC165)
        returns (bool)
    {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return uint256(_addressData[owner].balance);
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberMinted);
    }

    /**
     * Returns the number of tokens burned by or on behalf of `owner`.
     */
    function _numberBurned(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberBurned);
    }

    /**
     * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        return _addressData[owner].aux;
    }

    /**
     * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        _addressData[owner].aux = aux;
    }

    /**
     * Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around in the collection over time.
     */
    function _ownershipOf(uint256 tokenId)
        internal
        view
        returns (TokenOwnership memory)
    {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr)
                if (curr < _currentIndex) {
                    TokenOwnership memory ownership = _ownerships[curr];
                    if (!ownership.burned) {
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                        // Invariant:
                        // There will always be an ownership that has an address and is not burned
                        // before an ownership that does not have an address and is not burned.
                        // Hence, curr will not underflow.
                        while (true) {
                            curr--;
                            ownership = _ownerships[curr];
                            if (ownership.addr != address(0)) {
                                return ownership;
                            }
                        }
                    }
                }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view override returns (address) {
        return _ownershipOf(tokenId).addr;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

        string memory baseURI = _baseURI();
        return
            bytes(baseURI).length != 0
                ? string(abi.encodePacked(baseURI, tokenId.toString()))
                : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public override {
        address owner = ERC721A.ownerOf(tokenId);
        if (to == owner) revert ApprovalToCurrentOwner();

        if (_msgSender() != owner)
            if (!isApprovedForAll(owner, _msgSender())) {
                revert ApprovalCallerNotOwnerNorApproved();
            }

        _approve(to, tokenId, owner);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId)
        public
        view
        override
        returns (address)
    {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved)
        public
        virtual
        override
    {
        if (operator == _msgSender()) revert ApproveToCaller();

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator)
        public
        view
        virtual
        override
        returns (bool)
    {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (to.isContract())
            if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
                revert TransferToNonERC721ReceiverImplementer();
            }
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        return
            _startTokenId() <= tokenId &&
            tokenId < _currentIndex &&
            !_ownerships[tokenId].burned;
    }

    /**
     * @dev Equivalent to `_safeMint(to, quantity, '')`.
     */
    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, "");
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement
     *   {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            if (to.isContract()) {
                do {
                    emit Transfer(address(0), to, updatedIndex);
                    if (
                        !_checkContractOnERC721Received(
                            address(0),
                            to,
                            updatedIndex++,
                            _data
                        )
                    ) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (updatedIndex < end);
                // Reentrancy protection
                if (_currentIndex != startTokenId) revert();
            } else {
                do {
                    emit Transfer(address(0), to, updatedIndex++);
                } while (updatedIndex < end);
            }
            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 quantity) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            do {
                emit Transfer(address(0), to, updatedIndex++);
            } while (updatedIndex < end);

            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) private {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();

        bool isApprovedOrOwner = (_msgSender() == from ||
            isApprovedForAll(from, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId, from);

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = to;
            currSlot.startTimestamp = uint64(block.timestamp);

            // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, to, tokenId);
        _afterTokenTransfers(from, to, tokenId, 1);
    }

    /**
     * @dev Equivalent to `_burn(tokenId, false)`.
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        address from = prevOwnership.addr;

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSender() == from ||
                isApprovedForAll(from, _msgSender()) ||
                getApproved(tokenId) == _msgSender());

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

        _beforeTokenTransfers(from, address(0), tokenId, 1);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId, from);

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            AddressData storage addressData = _addressData[from];
            addressData.balance -= 1;
            addressData.numberBurned += 1;

            // Keep track of who burned the token, and the timestamp of burning.
            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = from;
            currSlot.startTimestamp = uint64(block.timestamp);
            currSlot.burned = true;

            // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, address(0), tokenId);
        _afterTokenTransfers(from, address(0), tokenId, 1);

        // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
        unchecked {
            _burnCounter++;
        }
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(
        address to,
        uint256 tokenId,
        address owner
    ) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        try
            IERC721Receiver(to).onERC721Received(
                _msgSender(),
                from,
                tokenId,
                _data
            )
        returns (bytes4 retval) {
            return retval == IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
     * minting.
     * And also called after one token has been burned.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}

interface IOperatorAccessControl {
    event RoleGranted(
        bytes32 indexed role,
        address indexed account,
        address indexed sender
    );

    event RoleRevoked(
        bytes32 indexed role,
        address indexed account,
        address indexed sender
    );

    function hasRole(bytes32 role, address account)
        external
        view
        returns (bool);

    function isOperator(address account) external view returns (bool);

    function addOperator(address account) external;

    function revokeOperator(address account) external;
}

contract OperatorAccessControl is IOperatorAccessControl, Ownable {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");

    function hasRole(bytes32 role, address account)
        public
        view
        override
        returns (bool)
    {
        return _roles[role].members[account];
    }

    function _grantRole(bytes32 role, address account) private {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    function _revokeRole(bytes32 role, address account) private {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }

    modifier isOperatorOrOwner() {
        address _sender = _msgSender();
        require(
            isOperator(_sender) || owner() == _sender,
            "OperatorAccessControl: caller is not operator or owner"
        );
        _;
    }

    modifier onlyOperator() {
        require(
            isOperator(_msgSender()),
            "OperatorAccessControl: caller is not operator"
        );
        _;
    }

    function isOperator(address account) public view override returns (bool) {
        return hasRole(OPERATOR_ROLE, account);
    }

    function _addOperator(address account) internal virtual {
        _grantRole(OPERATOR_ROLE, account);
    }

    function addOperator(address account) public override onlyOperator {
        _grantRole(OPERATOR_ROLE, account);
    }

    function revokeOperator(address account) public override onlyOperator {
        _revokeRole(OPERATOR_ROLE, account);
    }
}

library Base64 {
    bytes internal constant TABLE =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    /// @notice Encodes some bytes to the base64 representation
    function encode(bytes memory data) internal pure returns (string memory) {
        uint256 len = data.length;
        if (len == 0) return "";

        // multiply by 4/3 rounded up
        uint256 encodedLen = 4 * ((len + 2) / 3);

        // Add some extra buffer at the end
        bytes memory result = new bytes(encodedLen + 32);

        bytes memory table = TABLE;

        assembly {
            let tablePtr := add(table, 1)
            let resultPtr := add(result, 32)

            for {
                let i := 0
            } lt(i, len) {

            } {
                i := add(i, 3)
                let input := and(mload(add(data, i)), 0xffffff)

                let out := mload(add(tablePtr, and(shr(18, input), 0x3F)))
                out := shl(8, out)
                out := add(
                    out,
                    and(mload(add(tablePtr, and(shr(12, input), 0x3F))), 0xFF)
                )
                out := shl(8, out)
                out := add(
                    out,
                    and(mload(add(tablePtr, and(shr(6, input), 0x3F))), 0xFF)
                )
                out := shl(8, out)
                out := add(
                    out,
                    and(mload(add(tablePtr, and(input, 0x3F))), 0xFF)
                )
                out := shl(224, out)

                mstore(resultPtr, out)

                resultPtr := add(resultPtr, 4)
            }

            switch mod(len, 3)
            case 1 {
                mstore(sub(resultPtr, 2), shl(240, 0x3d3d))
            }
            case 2 {
                mstore(sub(resultPtr, 1), shl(248, 0x3d))
            }

            mstore(result, encodedLen)
        }

        return string(result);
    }
}

/*
                                                                                                                                                                        
                                                   :*****.    +***                ***=                                                                                  
        .-=                                        :#%%%%.    #%%%      .--      .%%%*                      ...   .::.          .::::.      ....      ....     ....     
       +%%%                                          +%%%.    =+++     #%%*       +++=                      +**+-*****+:      :+*******=.   +***.    +***+     +**+     
     ::#%%%:::.  :::::  -==:   .-====-:       .-===: +%%%.  .:::::   ::%%%*:::  ::::::       :====-.     ---************:    +****+++****:  -***-   :*****-   -***:     
     *%%%%%%%%- .%%%%%:#%%%+ .*%%%##%%%*.    +%%%%%%#*%%%.  =%%%%%   %%%%%%%%%. *%%%%*    .+%%%%%%%%+.   %%%****#%%%#***+   =***=.   :+***:  +***   +******.  +**+      
     ::*%%%:::.  :=%%%%#=--: +%%#.  .#%%+   +%%%+:.:+%%%%.  .:*%%%   ::%%%*:::  .:%%%*   .#%%%-..-#%%%.  :-%****. :#%***+  .***+      :***=  -***- -***.***- :***:      
       *%%%       -%%%#      ..:::---*%%#  .%%%*     +%%%.    +%%%     %%%*       #%%*   +%%%:    :%%%+   :%***+   =%***+  .***=      .***=   +**+.+**- -***.+**+       
       *%%%       -%%%-      :*%%%%%%%%%#  :%%%=     -%%%.    +%%%     %%%*       #%%*   *%%%      %%%#   :%***+   -%***+   ***+.     -***-   :***+**+   +**+***:       
       *%%%       -%%%:     .%%%*:.  +%%#  :%%%+     =%%%.    +%%%     %%%*       #%%*   *%%%.     %%%#   :%***+   -%***+   -***+-..:=***+.    +*****-   -*****+        
       *%%%  ##:  -%%%:     :%%%:   :%%%#   #%%%:   .#%%%.    +%%%     %%%* :##   #%%*   :%%%*    +%%%-   :%***+   -%***+    -**********+.     :****+     +****:        
       -%%%##%%..##%%%##-    #%%%++*%#%%%#= :#%%%**#%*%%%#* -#%%%%#*   +%%%*#%* +#%%%%#=  -%%%%**%%%%=   ##%####..##%####.    .-+****+=:        =+++:     :+++=         
        :*#%#+: .*******-     =*#%#+:-****-  .=*#%#*:.****+ :******=    =*#%#+. =******-   .-*#%%#*=.    *******..*******.                                              
        
*/
contract TNPASS is ERC721A, OperatorAccessControl, ReentrancyGuard {
    bytes32 public _kycMintMerkleRoot;
    bytes32 public _preMintMerkleRoot;

    mapping(uint256 => uint256) private stakeStarted;

    mapping(uint256 => uint256) private stakeTotal;

    mapping(address => uint256) private addressMintCount;

    uint256 private _kycMintLimit = 750;

    uint256 private _preMintLimit = 0;

    uint256 private _publicMintLimit = 0;

    uint256 private _addressMintLimit = 1;

    uint256 private _kycMintCount;

    uint256 private _preMintCount;

    uint256 private _publicMintCount;

    uint256 private _kycMintPrice = 3000000000000000000;

    uint256 private _preMintPrice = 10000000000000000000;

    uint256 private _publicMintPrice = 10000000000000000000;

    bool private _kycMintOpen = false;

    bool private _preMintOpen = false;

    bool private _publicMintOpen = false;

    uint256 _totalSupply = 1000;

    uint256 _totalTokens;

    bool private _transferOpen = false;

    string private _nftName = "TN PASS";
    string private _baseUri =
        "ipfs://QmXkDpDansBrLSLV63SwfEn1UkMgkskgL9hCSPqBRNrgWG";

    constructor() ERC721A(_nftName, _nftName) Ownable() {
        _addOperator(_msgSender());
    }

    function getMintCount()
        public
        view
        returns (
            uint256 kycMintCount,
            uint256 preMintCount,
            uint256 publicMintCount
        )
    {
        kycMintCount = _kycMintCount;
        preMintCount = _preMintCount;
        publicMintCount = _publicMintCount;
    }

    function setMerkleRoot(bytes32 kycMintMerkleRoot, bytes32 preMintMerkleRoot)
        public
        onlyOperator
    {
        _kycMintMerkleRoot = kycMintMerkleRoot;
        _preMintMerkleRoot = preMintMerkleRoot;
    }

    function isWhitelist(
        bytes32[] calldata kycMerkleProof,
        bytes32[] calldata preMerkleProof
    ) public view returns (bool isKycWhitelist, bool isPreWhitelist) {
        isKycWhitelist = MerkleProof.verify(
            kycMerkleProof,
            _kycMintMerkleRoot,
            keccak256(abi.encodePacked(msg.sender))
        );

        isPreWhitelist = MerkleProof.verify(
            preMerkleProof,
            _preMintMerkleRoot,
            keccak256(abi.encodePacked(msg.sender))
        );
    }

    function setMintLimit(
        uint256 kycMintLimit,
        uint256 preMintLimit,
        uint256 publicMintLimit,
        uint256 addressMintLimit
    ) public onlyOperator {
        _kycMintLimit = kycMintLimit;
        _preMintLimit = preMintLimit;
        _publicMintLimit = publicMintLimit;
        _addressMintLimit = addressMintLimit;
    }

    function getMintLimit()
        public
        view
        returns (
            uint256 kycMintLimit,
            uint256 preMintLimit,
            uint256 publicMintLimit,
            uint256 addressMintLimit
        )
    {
        kycMintLimit = _kycMintLimit;
        preMintLimit = _preMintLimit;
        publicMintLimit = _publicMintLimit;
        addressMintLimit = _addressMintLimit;
    }

    function setMintPrice(
        uint256 kycMintPrice,
        uint256 preMintPrice,
        uint256 publicMintPrice
    ) public onlyOperator {
        _kycMintPrice = kycMintPrice;
        _preMintPrice = preMintPrice;
        _publicMintPrice = publicMintPrice;
    }

    function getMintPrice()
        public
        view
        returns (
            uint256 kycMintPrice,
            uint256 preMintPrice,
            uint256 publicMintPrice
        )
    {
        kycMintPrice = _kycMintPrice;
        preMintPrice = _preMintPrice;
        publicMintPrice = _publicMintPrice;
    }

    function setSwith(
        bool kycMintOpen,
        bool preMintOpen,
        bool publicMintOpen,
        bool transferOpen
    ) public onlyOperator {
        _kycMintOpen = kycMintOpen;
        _preMintOpen = preMintOpen;
        _publicMintOpen = publicMintOpen;
        _transferOpen = transferOpen;
    }

    function getSwith()
        public
        view
        returns (
            bool kycMintOpen,
            bool preMintOpen,
            bool publicMintOpen,
            bool transferOpen
        )
    {
        kycMintOpen = _kycMintOpen;
        preMintOpen = _preMintOpen;
        publicMintOpen = _publicMintOpen;
        transferOpen = _transferOpen;
    }

    function _handleMint(address to) internal {
        require(
            addressMintCount[to] < _addressMintLimit,
            "error:10003 already claimed"
        );
        require(
            _totalTokens < _totalSupply,
            "error:10010 Exceeding the total amount"
        );

        _safeMint(to, 1);

        addressMintCount[to] = addressMintCount[to] + 1;

        _totalTokens = _totalTokens + 1;
    }

    function kycMint(bytes32[] calldata merkleProof)
        public
        payable
        nonReentrant
    {
        require(
            msg.value == _kycMintPrice,
            "error:10000 msg.value is incorrect"
        );

        require(_kycMintOpen, "error:10001 switch off");

        require(
            MerkleProof.verify(
                merkleProof,
                _kycMintMerkleRoot,
                keccak256(abi.encodePacked(msg.sender))
            ),
            "error:10002 not in the whitelist"
        );

        require(_kycMintCount < _kycMintLimit, "error:10004 Reach the limit");

        _handleMint(_msgSender());

        _kycMintCount = _kycMintCount + 1;
    }

    function preMint(bytes32[] calldata merkleProof)
        public
        payable
        nonReentrant
    {
        require(
            msg.value == _preMintPrice,
            "error:10000 msg.value is incorrect"
        );

        require(_preMintOpen, "error:10001 switch off");

        require(
            MerkleProof.verify(
                merkleProof,
                _preMintMerkleRoot,
                keccak256(abi.encodePacked(msg.sender))
            ),
            "error:10002 not in the whitelist"
        );

        require(_preMintCount < _preMintLimit, "error:10004 Reach the limit");

        _handleMint(_msgSender());

        _preMintCount = _preMintCount + 1;
    }

    function publicMint() public payable nonReentrant {
        require(
            msg.value == _publicMintPrice,
            "error:10000 msg.value is incorrect"
        );

        require(_publicMintOpen, "error:10001 switch off");

        require(
            _publicMintCount < _publicMintLimit,
            "error:10004 Reach the limit"
        );

        _handleMint(_msgSender());

        _publicMintCount = _publicMintCount + 1;
    }

    function operatorMint(uint256 amount, address to) public onlyOperator {
        for (uint256 i = 0; i < amount; ++i) {
            require(
                _totalTokens < _totalSupply,
                "error:10010 Exceeding the total amount"
            );

            _safeMint(to, 1);

            _totalTokens = _totalTokens + 1;
        }
    }

    function stakePeriod(uint256 tokenId)
        external
        view
        returns (
            bool isStake,
            uint256 current,
            uint256 total
        )
    {
        uint256 start = stakeStarted[tokenId];
        if (start != 0) {
            isStake = true;
            current = block.timestamp - start;
        }
        total = current + stakeTotal[tokenId];
    }

    function getStakeTime(uint256 tokenId) public view returns (uint256) {
        return stakeStarted[tokenId];
    }

    bool public stakeOpen = false;

    function setStakeOpen(bool open) external onlyOperator {
        stakeOpen = open;
    }

    event Staked(uint256 indexed tokenId, uint256 indexed time);

    event UnStaked(uint256 indexed tokenId, uint256 indexed time);

    function stake(uint256[] calldata tokenIds) external {
        require(stakeOpen, "error:10006 stake closed");

        uint256 n = tokenIds.length;
        for (uint256 i = 0; i < n; ++i) {
            uint256 tokenId = tokenIds[i];
            require(
                _ownershipOf(tokenId).addr == _msgSender(),
                "error:10005 Not owner"
            );

            uint256 start = stakeStarted[tokenId];
            if (start == 0) {
                stakeStarted[tokenId] = block.timestamp;
                emit Staked(tokenId, block.timestamp);
            }
        }
    }

    function unStake(uint256[] calldata tokenIds) external {
        uint256 n = tokenIds.length;
        for (uint256 i = 0; i < n; ++i) {
            uint256 tokenId = tokenIds[i];
            require(
                _ownershipOf(tokenId).addr == _msgSender(),
                "error:10005 Not owner"
            );

            uint256 start = stakeStarted[tokenId];
            if (start > 0) {
                stakeTotal[tokenId] += block.timestamp - start;
                stakeStarted[tokenId] = 0;
                emit UnStaked(tokenId, block.timestamp);
            }
        }
    }

    function operatorUnStake(uint256[] calldata tokenIds)
        external
        onlyOperator
    {
        uint256 n = tokenIds.length;
        for (uint256 i = 0; i < n; ++i) {
            uint256 tokenId = tokenIds[i];
            uint256 start = stakeStarted[tokenId];
            if (start > 0) {
                stakeTotal[tokenId] += block.timestamp - start;
                stakeStarted[tokenId] = 0;
                emit UnStaked(tokenId, block.timestamp);
            }
        }
    }

    uint256 private stakeTransfer = 1;

    function safeTransferWhileStake(
        address from,
        address to,
        uint256 tokenId
    ) external {
        require(ownerOf(tokenId) == _msgSender(), "error:10005 Not owner");
        stakeTransfer = 2;
        safeTransferFrom(from, to, tokenId);
        stakeTransfer = 1;
    }

    function _beforeTokenTransfers(
        address,
        address,
        uint256 startTokenId,
        uint256 quantity
    ) internal view override {
        uint256 tokenId = startTokenId;
        for (uint256 end = tokenId + quantity; tokenId < end; ++tokenId) {
            require(
                stakeStarted[tokenId] == 0 ||
                    stakeTransfer == 2 ||
                    _transferOpen,
                "error:10007 Stake can't transfer"
            );
        }
    }

    function setBaseUri(string memory baseUri) public onlyOperator {
        _baseUri = baseUri;
    }

    function tokenURI(uint256 tokenId)
        public
        view
        override
        returns (string memory)
    {
        return
            string(abi.encodePacked(_baseUri, "/", toString(tokenId), ".json"));
    }

    function supply() public view returns (uint256) {
        return _totalSupply;
    }

    function totalMinted() public view returns (uint256) {
        return _totalTokens;
    }

    function withdraw(address[] memory tokens, address _to)
        public
        onlyOperator
    {
        for (uint8 i; i < tokens.length; i++) {
            IERC20 token = IERC20(tokens[i]);
            uint256 b = token.balanceOf(address(this));
            if (b > 0) {
                token.transfer(_to, b);
            }
        }
        uint256 balance = address(this).balance;
        payable(_to).transfer(balance);
    }

    function toString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","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":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"time","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"time","type":"uint256"}],"name":"UnStaked","type":"event"},{"inputs":[],"name":"OPERATOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_kycMintMerkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_preMintMerkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMintCount","outputs":[{"internalType":"uint256","name":"kycMintCount","type":"uint256"},{"internalType":"uint256","name":"preMintCount","type":"uint256"},{"internalType":"uint256","name":"publicMintCount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMintLimit","outputs":[{"internalType":"uint256","name":"kycMintLimit","type":"uint256"},{"internalType":"uint256","name":"preMintLimit","type":"uint256"},{"internalType":"uint256","name":"publicMintLimit","type":"uint256"},{"internalType":"uint256","name":"addressMintLimit","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMintPrice","outputs":[{"internalType":"uint256","name":"kycMintPrice","type":"uint256"},{"internalType":"uint256","name":"preMintPrice","type":"uint256"},{"internalType":"uint256","name":"publicMintPrice","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getStakeTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSwith","outputs":[{"internalType":"bool","name":"kycMintOpen","type":"bool"},{"internalType":"bool","name":"preMintOpen","type":"bool"},{"internalType":"bool","name":"publicMintOpen","type":"bool"},{"internalType":"bool","name":"transferOpen","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isOperator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"kycMerkleProof","type":"bytes32[]"},{"internalType":"bytes32[]","name":"preMerkleProof","type":"bytes32[]"}],"name":"isWhitelist","outputs":[{"internalType":"bool","name":"isKycWhitelist","type":"bool"},{"internalType":"bool","name":"isPreWhitelist","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"kycMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"operatorMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"operatorUnStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"preMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"publicMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"revokeOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferWhileStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseUri","type":"string"}],"name":"setBaseUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"kycMintMerkleRoot","type":"bytes32"},{"internalType":"bytes32","name":"preMintMerkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"kycMintLimit","type":"uint256"},{"internalType":"uint256","name":"preMintLimit","type":"uint256"},{"internalType":"uint256","name":"publicMintLimit","type":"uint256"},{"internalType":"uint256","name":"addressMintLimit","type":"uint256"}],"name":"setMintLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"kycMintPrice","type":"uint256"},{"internalType":"uint256","name":"preMintPrice","type":"uint256"},{"internalType":"uint256","name":"publicMintPrice","type":"uint256"}],"name":"setMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"open","type":"bool"}],"name":"setStakeOpen","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"kycMintOpen","type":"bool"},{"internalType":"bool","name":"preMintOpen","type":"bool"},{"internalType":"bool","name":"publicMintOpen","type":"bool"},{"internalType":"bool","name":"transferOpen","type":"bool"}],"name":"setSwith","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakeOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"stakePeriod","outputs":[{"internalType":"bool","name":"isStake","type":"bool"},{"internalType":"uint256","name":"current","type":"uint256"},{"internalType":"uint256","name":"total","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"supply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"unStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"address","name":"_to","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

69838:12206:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43390:355;;;;;;;;;;-1:-1:-1;43390:355:0;;;;;:::i;:::-;;:::i;:::-;;;13566:14:1;;13559:22;13541:41;;13529:2;13514:18;43390:355:0;;;;;;;;80864:86;;;;;;;;;;-1:-1:-1;80930:12:0;;80864:86;;;14782:25:1;;;14770:2;14755:18;80864:86:0;14737:76:1;46676:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;48299:245::-;;;;;;;;;;-1:-1:-1;48299:245:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;12585:32:1;;;12567:51;;12555:2;12540:18;48299:245:0;12522:102:1;47839:394:0;;;;;;;;;;-1:-1:-1;47839:394:0;;;;;:::i;:::-;;:::i;:::-;;77905:610;;;;;;;;;;-1:-1:-1;77905:610:0;;;;;:::i;:::-;;:::i;75530:717::-;;;;;;:::i;:::-;;:::i;81057:444::-;;;;;;;;;;-1:-1:-1;81057:444:0;;;;;:::i;:::-;;:::i;69912:33::-;;;;;;;;;;;;;;;;42630:312;;;;;;;;;;-1:-1:-1;42893:12:0;;42683:7;42877:13;:28;42630:312;;49287:170;;;;;;;;;;-1:-1:-1;49287:170:0;;;;;:::i;:::-;;:::i;76255:460::-;;;:::i;69952:33::-;;;;;;;;;;;;;;;;73028:276;;;;;;;;;;-1:-1:-1;73028:276:0;;;;;:::i;:::-;;:::i;49528:185::-;;;;;;;;;;-1:-1:-1;49528:185:0;;;;;:::i;:::-;;:::i;79136:507::-;;;;;;;;;;-1:-1:-1;79136:507:0;;;;;:::i;:::-;;:::i;72607:413::-;;;;;;;;;;-1:-1:-1;72868:13:0;;72907;;72949:16;;72995:17;;72607:413;;;20619:25:1;;;20675:2;20660:18;;20653:34;;;;20703:18;;;20696:34;20761:2;20746:18;;20739:34;20606:3;20591:19;72607:413:0;20573:206:1;46484:125:0;;;;;;;;;;-1:-1:-1;46484:125:0;;;;;:::i;:::-;;:::i;72241:358::-;;;;;;;;;;-1:-1:-1;72241:358:0;;;;;:::i;:::-;;:::i;65096:130::-;;;;;;;;;;-1:-1:-1;65096:130:0;;;;;:::i;:::-;;:::i;43809:206::-;;;;;;;;;;-1:-1:-1;43809:206:0;;;;;:::i;:::-;;:::i;16723:103::-;;;;;;;;;;;;;:::i;71464:226::-;;;;;;;;;;-1:-1:-1;71464:226:0;;;;;:::i;:::-;;:::i;77507:116::-;;;;;;;;;;-1:-1:-1;77507:116:0;;;;;:::i;:::-;77567:7;77594:21;;;:12;:21;;;;;;;77507:116;71698:535;;;;;;;;;;-1:-1:-1;71698:535:0;;;;;:::i;:::-;;:::i;:::-;;;;13780:14:1;;13773:22;13755:41;;13839:14;;13832:22;13827:2;13812:18;;13805:50;13728:18;71698:535:0;13710:151:1;16075:87:0;;;;;;;;;;-1:-1:-1;16148:6:0;;-1:-1:-1;;;;;16148:6:0;16075:87;;71129:327;;;;;;;;;;-1:-1:-1;71351:13:0;;71390;;71432:16;;71129:327;;;;20266:25:1;;;20322:2;20307:18;;20300:34;;;;20350:18;;;20343:34;20254:2;20239:18;71129:327:0;20221:162:1;63877:180:0;;;;;;;;;;-1:-1:-1;63877:180:0;;;;;:::i;:::-;;:::i;73647:321::-;;;;;;;;;;-1:-1:-1;73647:321:0;;;;;:::i;:::-;;:::i;46845:104::-;;;;;;;;;;;;;:::i;65351:120::-;;;;;;;;;;-1:-1:-1;65351:120:0;;;;;:::i;:::-;;:::i;79693:305::-;;;;;;;;;;-1:-1:-1;79693:305:0;;;;;:::i;:::-;;:::i;80521:100::-;;;;;;;;;;-1:-1:-1;80521:100:0;;;;;:::i;:::-;;:::i;48616:319::-;;;;;;;;;;-1:-1:-1;48616:319:0;;;;;:::i;:::-;;:::i;80958:91::-;;;;;;;;;;-1:-1:-1;81029:12:0;;80958:91;;73312:327;;;;;;;;;;-1:-1:-1;73534:13:0;;73573;;73615:16;;73312:327;;73976:376;;;;;;;;;;-1:-1:-1;74213:12:0;;74331:13;;73976:376;;;74213:12;;;;14098:14:1;14091:22;14073:41;;74213:12:0;74250;;;;14157:14:1;14150:22;14145:2;14130:18;;14123:50;74290:15:0;;;;;;14216:14:1;14209:22;14189:18;;;14182:50;;;;74331:13:0;;14275:14:1;14268:22;14263:2;14248:18;;14241:50;14060:3;14045:19;73976:376:0;14027:270:1;78523:605:0;;;;;;;;;;-1:-1:-1;78523:605:0;;;;;:::i;:::-;;:::i;77631:29::-;;;;;;;;;;-1:-1:-1;77631:29:0;;;;;;;;77091:408;;;;;;;;;;-1:-1:-1;77091:408:0;;;;;:::i;:::-;;:::i;:::-;;;;14523:14:1;;14516:22;14498:41;;14570:2;14555:18;;14548:34;;;;14598:18;;;14591:34;14486:2;14471:18;77091:408:0;14453:178:1;49784:392:0;;;;;;;;;;-1:-1:-1;49784:392:0;;;;;:::i;:::-;;:::i;76723:360::-;;;;;;;;;;-1:-1:-1;76723:360:0;;;;;:::i;:::-;;:::i;80629:227::-;;;;;;;;;;-1:-1:-1;80629:227:0;;;;;:::i;:::-;;:::i;74805:717::-;;;;;;:::i;:::-;;:::i;77669:90::-;;;;;;;;;;-1:-1:-1;77669:90:0;;;;;:::i;:::-;;:::i;49006:214::-;;;;;;;;;;-1:-1:-1;49006:214:0;;;;;:::i;:::-;-1:-1:-1;;;;;49177:25:0;;;49148:4;49177:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;49006:214;16981:238;;;;;;;;;;-1:-1:-1;16981:238:0;;;;;:::i;:::-;;:::i;63802:66::-;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;63802:66:0;;65479:124;;;;;;;;;;-1:-1:-1;65479:124:0;;;;;:::i;:::-;;:::i;43390:355::-;43537:4;-1:-1:-1;;;;;;43579:40:0;;-1:-1:-1;;;43579:40:0;;:105;;-1:-1:-1;;;;;;;43636:48:0;;-1:-1:-1;;;43636:48:0;43579:105;:158;;;-1:-1:-1;;;;;;;;;;40571:40:0;;;43701:36;43559:178;43390:355;-1:-1:-1;;43390:355:0:o;46676:100::-;46730:13;46763:5;46756:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46676:100;:::o;48299:245::-;48403:7;48433:16;48441:7;48433;:16::i;:::-;48428:64;;48458:34;;-1:-1:-1;;;48458:34:0;;;;;;;;;;;48428:64;-1:-1:-1;48512:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;48512:24:0;;48299:245::o;47839:394::-;47912:13;47928:24;47944:7;47928:15;:24::i;:::-;47912:40;;47973:5;-1:-1:-1;;;;;47967:11:0;:2;-1:-1:-1;;;;;47967:11:0;;47963:48;;;47987:24;;-1:-1:-1;;;47987:24:0;;;;;;;;;;;47963:48;12325:10;-1:-1:-1;;;;;48028:21:0;;;48024:161;;48069:37;48086:5;12325:10;49006:214;:::i;48069:37::-;48064:121;;48134:35;;-1:-1:-1;;;48134:35:0;;;;;;;;;;;48064:121;48197:28;48206:2;48210:7;48219:5;48197:8;:28::i;:::-;47839:394;;;:::o;77905:610::-;77977:9;;;;77969:46;;;;-1:-1:-1;;;77969:46:0;;18550:2:1;77969:46:0;;;18532:21:1;18589:2;18569:18;;;18562:30;18628:26;18608:18;;;18601:54;18672:18;;77969:46:0;;;;;;;;;78040:8;78028:9;78066:442;78090:1;78086;:5;78066:442;;;78113:15;78131:8;;78140:1;78131:11;;;;;-1:-1:-1;;;78131:11:0;;;;;;;;;;;;;;;78113:29;;78213:12;12325:10;;12245:98;78213:12;-1:-1:-1;;;;;78183:42:0;:21;78196:7;78183:12;:21::i;:::-;:26;-1:-1:-1;;;;;78183:42:0;;78157:125;;;;-1:-1:-1;;;78157:125:0;;;;;;;:::i;:::-;78299:13;78315:21;;;:12;:21;;;;;;78355:10;78351:146;;78386:21;;;;:12;:21;;;;;;78410:15;78386:39;;;;78449:32;;78410:15;;78399:7;;78449:32;;78386:21;78449:32;78351:146;78066:442;;78093:3;;;;:::i;:::-;;;78066:442;;;;77905:610;;;:::o;75530:717::-;10704:1;11302:7;;:19;;11294:63;;;;-1:-1:-1;;;11294:63:0;;;;;;;:::i;:::-;10704:1;11435:7;:18;75685:13:::1;::::0;75672:9:::1;:26;75650:110;;;;-1:-1:-1::0;;;75650:110:0::1;;;;;;;:::i;:::-;75781:12;::::0;::::1;::::0;::::1;;;75773:47;;;;-1:-1:-1::0;;;75773:47:0::1;;;;;;;:::i;:::-;75855:158;75892:11;;75855:158;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;75922:18:0::1;::::0;75969:28:::1;::::0;75922:18;;-1:-1:-1;75969:28:0::1;::::0;-1:-1:-1;75986:10:0::1;::::0;75969:28:::1;;;:::i;:::-;;;;;;;;;;;;;75959:39;;;;;;75855:18;:158::i;:::-;75833:240;;;::::0;-1:-1:-1;;;75833:240:0;;17478:2:1;75833:240:0::1;::::0;::::1;17460:21:1::0;;;17497:18;;;17490:30;17556:34;17536:18;;;17529:62;17608:18;;75833:240:0::1;17450:182:1::0;75833:240:0::1;76110:13;;76094;;:29;76086:69;;;;-1:-1:-1::0;;;76086:69:0::1;;;;;;;:::i;:::-;76168:25;12325:10:::0;76168:11:::1;:25::i;:::-;76222:13;::::0;:17:::1;::::0;76238:1:::1;76222:17;:::i;:::-;76206:13;:33:::0;-1:-1:-1;;10660:1:0;11614:7;:22;75530:717::o;81057:444::-;64971:24;12325:10;65096:130;:::i;64971:24::-;64949:119;;;;-1:-1:-1;;;64949:119:0;;;;;;;:::i;:::-;81172:7:::1;81167:236;81185:6;:13;81181:1;:17;;;81167:236;;;81220:12;81242:6;81249:1;81242:9;;;;;;;;-1:-1:-1::0;;;81242:9:0::1;;;;;;;;;;::::0;;::::1;::::0;;;;;;81279:30:::1;::::0;-1:-1:-1;;;81279:30:0;;81303:4:::1;81279:30;::::0;::::1;12567:51:1::0;81242:9:0;;-1:-1:-1;81267:9:0::1;::::0;-1:-1:-1;;;;;81279:15:0;::::1;::::0;::::1;::::0;12540:18:1;;81279:30:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;81267:42:::0;-1:-1:-1;81328:5:0;;81324:68:::1;;81354:22;::::0;-1:-1:-1;;;81354:22:0;;-1:-1:-1;;;;;13314:32:1;;;81354:22:0::1;::::0;::::1;13296:51:1::0;13363:18;;;13356:34;;;81354:14:0;::::1;::::0;::::1;::::0;13269:18:1;;81354:22:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;81324:68;81167:236;;81200:3;;;;;:::i;:::-;;;;81167:236;;;-1:-1:-1::0;81463:30:0::1;::::0;81431:21:::1;::::0;-1:-1:-1;;;;;81463:21:0;::::1;::::0;:30;::::1;;;::::0;81431:21;;81413:15:::1;81463:30:::0;81413:15;81463:30;81431:21;81463;:30;::::1;;;;;;;;;;;;;::::0;::::1;;;;49287:170:::0;49421:28;49431:4;49437:2;49441:7;49421:9;:28::i;76255:460::-;10704:1;11302:7;;:19;;11294:63;;;;-1:-1:-1;;;11294:63:0;;;;;;;:::i;:::-;10704:1;11435:7;:18;76351:16:::1;::::0;76338:9:::1;:29;76316:113;;;;-1:-1:-1::0;;;76316:113:0::1;;;;;;;:::i;:::-;76450:15;::::0;;;::::1;;;76442:50;;;;-1:-1:-1::0;;;76442:50:0::1;;;;;;;:::i;:::-;76546:16;;76527;;:35;76505:112;;;;-1:-1:-1::0;;;76505:112:0::1;;;;;;;:::i;:::-;76630:25;12325:10:::0;76168:11:::1;:25::i;76630:::-;76687:16;::::0;:20:::1;::::0;76706:1:::1;76687:20;:::i;:::-;76668:16;:39:::0;10660:1;11614:7;:22;76255:460::o;73028:276::-;64971:24;12325:10;65096:130;:::i;64971:24::-;64949:119;;;;-1:-1:-1;;;64949:119:0;;;;;;;:::i;:::-;73184:13:::1;:28:::0;;;;73223:13:::1;:28:::0;73262:16:::1;:34:::0;73028:276::o;49528:185::-;49666:39;49683:4;49689:2;49693:7;49666:39;;;;;;;;;;;;:16;:39::i;79136:507::-;64971:24;12325:10;65096:130;:::i;64971:24::-;64949:119;;;;-1:-1:-1;;;64949:119:0;;;;;;;:::i;:::-;79258:8;79246:9:::1;79284:352;79308:1;79304;:5;79284:352;;;79331:15;79349:8;;79358:1;79349:11;;;;;-1:-1:-1::0;;;79349:11:0::1;;;;;;;;;;::::0;;::::1;::::0;;;::::1;;79375:13;79391:21:::0;;;:12:::1;:21:::0;;;;;;;;79349:11;;-1:-1:-1;;79431:9:0;;79427:198:::1;;79484:23;79502:5:::0;79484:15:::1;:23;:::i;:::-;79461:19;::::0;;;:10:::1;:19;::::0;;;;:46;;:19;;;:46:::1;::::0;;;::::1;:::i;:::-;::::0;;;-1:-1:-1;;79550:1:0::1;79526:21:::0;;;:12:::1;:21;::::0;;;;;:25;;;79575:34;79593:15:::1;::::0;79539:7;;79575:34:::1;::::0;79550:1;79575:34:::1;79427:198;79284:352;;79311:3;;;;:::i;:::-;;;79284:352;;46484:125:::0;46548:7;46575:21;46588:7;46575:12;:21::i;:::-;:26;;46484:125;-1:-1:-1;;46484:125:0:o;72241:358::-;64971:24;12325:10;65096:130;:::i;64971:24::-;64949:119;;;;-1:-1:-1;;;64949:119:0;;;;;;;:::i;:::-;72432:13:::1;:28:::0;;;;72471:13:::1;:28:::0;;;;72510:16:::1;:34:::0;72555:17:::1;:36:::0;72241:358::o;65096:130::-;65163:4;65187:31;-1:-1:-1;;;;;;;;;;;65210:7:0;65187;:31::i;43809:206::-;43873:7;-1:-1:-1;;;;;43897:19:0;;43893:60;;43925:28;;-1:-1:-1;;;43925:28:0;;;;;;;;;;;43893:60;-1:-1:-1;;;;;;43979:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;43979:27:0;;43809:206::o;16723:103::-;15961:13;:11;:13::i;:::-;16788:30:::1;16815:1;16788:18;:30::i;:::-;16723:103::o:0;71464:226::-;64971:24;12325:10;65096:130;:::i;64971:24::-;64949:119;;;;-1:-1:-1;;;64949:119:0;;;;;;;:::i;:::-;71595:18:::1;:38:::0;;;;71644:18:::1;:38:::0;71464:226::o;71698:535::-;71835:19;71856;71905:145;71938:14;;71905:145;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;71967:18:0;;72010:28;;71967:18;;-1:-1:-1;72010:28:0;;-1:-1:-1;72027:10:0;;72010:28;;;:::i;71905:145::-;71888:162;;72080:145;72113:14;;72080:145;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;72142:18:0;;72185:28;;72142:18;;-1:-1:-1;72185:28:0;;-1:-1:-1;72202:10:0;;72185:28;;;:::i;72080:145::-;72063:162;;71698:535;;;;;;;:::o;63877:180::-;63991:4;64020:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;64020:29:0;;;;;;;;;;;;;;;63877:180::o;73647:321::-;64971:24;12325:10;65096:130;:::i;64971:24::-;64949:119;;;;-1:-1:-1;;;64949:119:0;;;;;;;:::i;:::-;73815:12:::1;:26:::0;;-1:-1:-1;;73852:26:0;73815;::::1;;-1:-1:-1::0;;73852:26:0;;;;;73815::::1;73852::::0;::::1;;::::0;;;::::1;::::0;;;::::1;-1:-1:-1::0;;73889:32:0::1;::::0;;::::1;;::::0;;;::::1;;::::0;;;73932:13:::1;:28:::0;;-1:-1:-1;;73932:28:0::1;::::0;::::1;;::::0;;;::::1;::::0;;73647:321::o;46845:104::-;46901:13;46934:7;46927:14;;;;;:::i;65351:120::-;64971:24;12325:10;65096:130;:::i;64971:24::-;64949:119;;;;-1:-1:-1;;;64949:119:0;;;;;;;:::i;:::-;65429:34:::1;-1:-1:-1::0;;;;;;;;;;;65455:7:0::1;65429:10;:34::i;:::-;65351:120:::0;:::o;79693:305::-;12325:10;79830:16;79838:7;79830;:16::i;:::-;-1:-1:-1;;;;;79830:32:0;;79822:66;;;;-1:-1:-1;;;79822:66:0;;;;;;;:::i;:::-;79915:1;79899:13;:17;79927:35;79944:4;79950:2;79954:7;79927:16;:35::i;:::-;-1:-1:-1;;79989:1:0;79973:13;:17;-1:-1:-1;79693:305:0:o;80521:100::-;64971:24;12325:10;65096:130;:::i;64971:24::-;64949:119;;;;-1:-1:-1;;;64949:119:0;;;;;;;:::i;:::-;80595:18;;::::1;::::0;:8:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;:::-;;80521:100:::0;:::o;48616:319::-;-1:-1:-1;;;;;48747:24:0;;12325:10;48747:24;48743:54;;;48780:17;;-1:-1:-1;;;48780:17:0;;;;;;;;;;;48743:54;12325:10;48810:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;48810:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;48810:53:0;;;;;;;;;;48879:48;;13541:41:1;;;48810:42:0;;12325:10;48879:48;;13514:18:1;48879:48:0;;;;;;;48616:319;;:::o;78523:605::-;78601:8;78589:9;78627:494;78651:1;78647;:5;78627:494;;;78674:15;78692:8;;78701:1;78692:11;;;;;-1:-1:-1;;;78692:11:0;;;;;;;;;;;;;;;78674:29;;78774:12;12325:10;;12245:98;78774:12;-1:-1:-1;;;;;78744:42:0;:21;78757:7;78744:12;:21::i;:::-;:26;-1:-1:-1;;;;;78744:42:0;;78718:125;;;;-1:-1:-1;;;78718:125:0;;;;;;;:::i;:::-;78860:13;78876:21;;;:12;:21;;;;;;78916:9;;78912:198;;78969:23;78987:5;78969:15;:23;:::i;:::-;78946:19;;;;:10;:19;;;;;:46;;:19;;;:46;;;;;:::i;:::-;;;;-1:-1:-1;;79035:1:0;79011:21;;;:12;:21;;;;;;:25;;;79060:34;79078:15;;79024:7;;79060:34;;79035:1;79060:34;78912:198;78627:494;;78654:3;;;;:::i;:::-;;;78627:494;;77091:408;77193:12;77307:21;;;:12;:21;;;;;;77193:12;;;;77343:10;;77339:105;;77380:4;;-1:-1:-1;77409:23:0;77427:5;77409:15;:23;:::i;:::-;77399:33;;77339:105;77472:19;;;;:10;:19;;;;;;77462:29;;:7;:29;:::i;:::-;77091:408;;;;-1:-1:-1;;;77091:408:0:o;49784:392::-;49951:28;49961:4;49967:2;49971:7;49951:9;:28::i;:::-;-1:-1:-1;;;;;49994:13:0;;19020:19;:23;49990:179;;50029:56;50060:4;50066:2;50070:7;50079:5;50029:30;:56::i;:::-;50024:145;;50113:40;;-1:-1:-1;;;50113:40:0;;;;;;;;;;;76723:360;64971:24;12325:10;65096:130;:::i;64971:24::-;64949:119;;;;-1:-1:-1;;;64949:119:0;;;;;;;:::i;:::-;76809:9:::1;76804:272;76828:6;76824:1;:10;76804:272;;;76897:12;;76882;;:27;76856:127;;;;-1:-1:-1::0;;;76856:127:0::1;;;;;;;:::i;:::-;77000:16;77010:2;77014:1;77000:9;:16::i;:::-;77048:12;::::0;:16:::1;::::0;77063:1:::1;77048:16;:::i;:::-;77033:12;:31:::0;76836:3:::1;::::0;::::1;:::i;:::-;;;76804:272;;80629:227:::0;80730:13;80805:8;80820:17;80829:7;80820:8;:17::i;:::-;80788:59;;;;;;;;;:::i;:::-;;;;;;;;;;;;;80761:87;;80629:227;;;:::o;74805:717::-;10704:1;11302:7;;:19;;11294:63;;;;-1:-1:-1;;;11294:63:0;;;;;;;:::i;:::-;10704:1;11435:7;:18;74960:13:::1;::::0;74947:9:::1;:26;74925:110;;;;-1:-1:-1::0;;;74925:110:0::1;;;;;;;:::i;:::-;75056:12;::::0;::::1;;75048:47;;;;-1:-1:-1::0;;;75048:47:0::1;;;;;;;:::i;:::-;75130:158;75167:11;;75130:158;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;75197:18:0::1;::::0;75244:28:::1;::::0;75197:18;;-1:-1:-1;75244:28:0::1;::::0;-1:-1:-1;75261:10:0::1;::::0;75244:28:::1;;;:::i;75130:158::-;75108:240;;;::::0;-1:-1:-1;;;75108:240:0;;17478:2:1;75108:240:0::1;::::0;::::1;17460:21:1::0;;;17497:18;;;17490:30;17556:34;17536:18;;;17529:62;17608:18;;75108:240:0::1;17450:182:1::0;75108:240:0::1;75385:13;;75369;;:29;75361:69;;;;-1:-1:-1::0;;;75361:69:0::1;;;;;;;:::i;:::-;75443:25;12325:10:::0;76168:11:::1;:25::i;75443:::-;75497:13;::::0;:17:::1;::::0;75513:1:::1;75497:17;:::i;:::-;75481:13;:33:::0;-1:-1:-1;;10660:1:0;11614:7;:22;74805:717::o;77669:90::-;64971:24;12325:10;65096:130;:::i;64971:24::-;64949:119;;;;-1:-1:-1;;;64949:119:0;;;;;;;:::i;:::-;77735:9:::1;:16:::0;;-1:-1:-1;;77735:16:0::1;::::0;::::1;;::::0;;;::::1;::::0;;77669:90::o;16981:238::-;15961:13;:11;:13::i;:::-;-1:-1:-1;;;;;17084:22:0;::::1;17062:110;;;::::0;-1:-1:-1;;;17062:110:0;;16307:2:1;17062:110:0::1;::::0;::::1;16289:21:1::0;16346:2;16326:18;;;16319:30;16385:34;16365:18;;;16358:62;-1:-1:-1;;;16436:18:1;;;16429:36;16482:19;;17062:110:0::1;16279:228:1::0;17062:110:0::1;17183:28;17202:8;17183:18;:28::i;65479:124::-:0;64971:24;12325:10;65096:130;:::i;64971:24::-;64949:119;;;;-1:-1:-1;;;64949:119:0;;;;;;;:::i;:::-;65560:35:::1;-1:-1:-1::0;;;;;;;;;;;65587:7:0::1;65560:11;:35::i;50431:213::-:0;50488:4;50578:13;;50568:7;:23;50525:111;;;;-1:-1:-1;;50609:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;50609:27:0;;;;50608:28;;50431:213::o;59883:196::-;59998:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;59998:29:0;-1:-1:-1;;;;;59998:29:0;;;;;;;;;60043:28;;59998:24;;60043:28;;;;;;;59883:196;;;:::o;45190:1232::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;45333:7:0;45435:13;;45428:4;:20;45424:931;;;45473:31;45507:17;;;:11;:17;;;;;;;;;45473:51;;;;;;;;;-1:-1:-1;;;;;45473:51:0;;;;-1:-1:-1;;;45473:51:0;;-1:-1:-1;;;;;45473:51:0;;;;;;;;-1:-1:-1;;;45473:51:0;;;;;;;;;;;;;;45547:789;;45601:14;;-1:-1:-1;;;;;45601:28:0;;45597:109;;45669:9;45190:1232;-1:-1:-1;;;45190:1232:0:o;45597:109::-;-1:-1:-1;;;46072:6:0;46121:17;;;;:11;:17;;;;;;;;;46109:29;;;;;;;;;-1:-1:-1;;;;;46109:29:0;;;;;-1:-1:-1;;;46109:29:0;;-1:-1:-1;;;;;46109:29:0;;;;;;;;-1:-1:-1;;;46109:29:0;;;;;;;;;;;;;46173:28;46169:117;;46245:9;45190:1232;-1:-1:-1;;;45190:1232:0:o;46169:117::-;46028:285;;;45424:931;;46383:31;;-1:-1:-1;;;46383:31:0;;;;;;;;;;;1176:190;1301:4;1354;1325:25;1338:5;1345:4;1325:12;:25::i;:::-;:33;;1176:190;-1:-1:-1;;;;1176:190:0:o;74360:437::-;74458:17;;-1:-1:-1;;;;;74435:20:0;;;;;;:16;:20;;;;;;:40;74413:117;;;;-1:-1:-1;;;74413:117:0;;15951:2:1;74413:117:0;;;15933:21:1;15990:2;15970:18;;;15963:30;16029:29;16009:18;;;16002:57;16076:18;;74413:117:0;15923:177:1;74413:117:0;74578:12;;74563;;:27;74541:115;;;;-1:-1:-1;;;74541:115:0;;;;;;;:::i;:::-;74669:16;74679:2;74683:1;74669:9;:16::i;:::-;-1:-1:-1;;;;;74721:20:0;;;;;;:16;:20;;;;;;:24;;74744:1;74721:24;:::i;:::-;-1:-1:-1;;;;;74698:20:0;;;;;;:16;:20;;;;;:47;74773:12;;:16;;74788:1;74773:16;:::i;:::-;74758:12;:31;-1:-1:-1;74360:437:0:o;54831:2130::-;54946:35;54984:21;54997:7;54984:12;:21::i;:::-;54946:59;;55044:4;-1:-1:-1;;;;;55022:26:0;:13;:18;;;-1:-1:-1;;;;;55022:26:0;;55018:67;;55057:28;;-1:-1:-1;;;55057:28:0;;;;;;;;;;;55018:67;55098:22;12325:10;-1:-1:-1;;;;;55124:20:0;;;;:73;;-1:-1:-1;55161:36:0;55178:4;12325:10;49006:214;:::i;55161:36::-;55124:126;;;-1:-1:-1;12325:10:0;55214:20;55226:7;55214:11;:20::i;:::-;-1:-1:-1;;;;;55214:36:0;;55124:126;55098:153;;55269:17;55264:66;;55295:35;;-1:-1:-1;;;55295:35:0;;;;;;;;;;;55264:66;-1:-1:-1;;;;;55345:16:0;;55341:52;;55370:23;;-1:-1:-1;;;55370:23:0;;;;;;;;;;;55341:52;55406:43;55428:4;55434:2;55438:7;55447:1;55406:21;:43::i;:::-;55514:35;55531:1;55535:7;55544:4;55514:8;:35::i;:::-;-1:-1:-1;;;;;55845:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;55845:31:0;;;-1:-1:-1;;;;;55845:31:0;;;-1:-1:-1;;55845:31:0;;;;;;;55891:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;55891:29:0;;;;;;;;;;;55971:20;;;:11;:20;;;;;;56006:18;;-1:-1:-1;;;;;;56039:49:0;;;;-1:-1:-1;;;56072:15:0;56039:49;;;;;;;;;;56362:11;;56422:24;;;;;56465:13;;55971:20;;56422:24;;56465:13;56461:384;;56675:13;;56660:11;:28;56656:174;;56713:20;;56782:28;;;;-1:-1:-1;;;;;56756:54:0;-1:-1:-1;;;56756:54:0;-1:-1:-1;;;;;;56756:54:0;;;-1:-1:-1;;;;;56713:20:0;;56756:54;;;;56656:174;54831:2130;;;56892:7;56888:2;-1:-1:-1;;;;;56873:27:0;56882:4;-1:-1:-1;;;;;56873:27:0;;;;;;;;;;;54831:2130;;;;;:::o;16240:132::-;16148:6;;-1:-1:-1;;;;;16148:6:0;12325:10;16304:23;16296:68;;;;-1:-1:-1;;;16296:68:0;;17117:2:1;16296:68:0;;;17099:21:1;;;17136:18;;;17129:30;17195:34;17175:18;;;17168:62;17247:18;;16296:68:0;17089:182:1;17379:191:0;17472:6;;;-1:-1:-1;;;;;17489:17:0;;;-1:-1:-1;;;;;;17489:17:0;;;;;;;17522:40;;17472:6;;;17489:17;17472:6;;17522:40;;17453:16;;17522:40;17379:191;;:::o;64065:229::-;64140:22;64148:4;64154:7;64140;:22::i;:::-;64135:152;;64179:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;64179:29:0;;;;;;;;;:36;;-1:-1:-1;;64179:36:0;64211:4;64179:36;;;64262:12;12325:10;;12245:98;64262:12;-1:-1:-1;;;;;64235:40:0;64253:7;-1:-1:-1;;;;;64235:40:0;64247:4;64235:40;;;;;;;;;;64065:229;;:::o;60571:772::-;60768:155;;-1:-1:-1;;;60768:155:0;;60734:4;;-1:-1:-1;;;;;60768:36:0;;;;;:155;;12325:10;;60854:4;;60877:7;;60903:5;;60768:155;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60768:155:0;;;;;;;;-1:-1:-1;;60768:155:0;;;;;;;;;;;;:::i;:::-;;;60751:585;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;61094:13:0;;61090:235;;61140:40;;-1:-1:-1;;;61140:40:0;;;;;;;;;;;61090:235;61283:6;61277:13;61268:6;61264:2;61260:15;61253:38;60751:585;-1:-1:-1;;;;;;60979:55:0;-1:-1:-1;;;60979:55:0;;-1:-1:-1;60751:585:0;60571:772;;;;;;:::o;50728:104::-;50797:27;50807:2;50811:8;50797:27;;;;;;;;;;;;:9;:27::i;81509:532::-;81565:13;81595:10;81591:53;;-1:-1:-1;;81622:10:0;;;;;;;;;;;;-1:-1:-1;;;81622:10:0;;;;;81509:532::o;81591:53::-;81669:5;81654:12;81710:78;81717:9;;81710:78;;81743:8;;;;:::i;:::-;;-1:-1:-1;81766:10:0;;-1:-1:-1;81774:2:0;81766:10;;:::i;:::-;;;81710:78;;;81798:19;81830:6;-1:-1:-1;;;;;81820:17:0;;;;;-1:-1:-1;;;81820:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;81820:17:0;;81798:39;;81848:154;81855:10;;81848:154;;81882:11;81892:1;81882:11;;:::i;:::-;;-1:-1:-1;81951:10:0;81959:2;81951:5;:10;:::i;:::-;81938:24;;:2;:24;:::i;:::-;81925:39;;81908:6;81915;81908:14;;;;;;-1:-1:-1;;;81908:14:0;;;;;;;;;;;;:56;-1:-1:-1;;;;;81908:56:0;;;;;;;;-1:-1:-1;81979:11:0;81988:2;81979:11;;:::i;:::-;;;81848:154;;64422:230;64497:22;64505:4;64511:7;64497;:22::i;:::-;64493:152;;;64568:5;64536:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;64536:29:0;;;;;;;;;;:37;;-1:-1:-1;;64536:37:0;;;64593:40;12325:10;;64536:12;;64593:40;;64568:5;64593:40;64422:230;;:::o;2043:328::-;2153:7;2201:4;2153:7;2216:118;2240:5;:12;2236:1;:16;2216:118;;;2289:33;2299:12;2313:5;2319:1;2313:8;;;;;;-1:-1:-1;;;2313:8:0;;;;;;;;;;;;;;;2289:9;:33::i;:::-;2274:48;-1:-1:-1;2254:3:0;;;;:::i;:::-;;;;2216:118;;;-1:-1:-1;2351:12:0;2043:328;-1:-1:-1;;;2043:328:0:o;80006:507::-;80190:12;80172:15;80232:18;80242:8;80190:12;80232:18;:::i;:::-;80218:32;;80213:293;80262:3;80252:7;:13;80213:293;;;80319:21;;;;:12;:21;;;;;;:26;;:69;;;80370:13;;80387:1;80370:18;80319:69;:107;;;-1:-1:-1;80413:13:0;;;;80319:107;80293:201;;;;-1:-1:-1;;;80293:201:0;;17839:2:1;80293:201:0;;;17821:21:1;;;17858:18;;;17851:30;17917:34;17897:18;;;17890:62;17969:18;;80293:201:0;17811:182:1;80293:201:0;80267:9;;;:::i;:::-;;;80213:293;;;;80006:507;;;;;:::o;51205:1940::-;51328:20;51351:13;-1:-1:-1;;;;;51379:16:0;;51375:48;;51404:19;;-1:-1:-1;;;51404:19:0;;;;;;;;;;;51375:48;51438:13;51434:44;;51460:18;;-1:-1:-1;;;51460:18:0;;;;;;;;;;;51434:44;51491:61;51521:1;51525:2;51529:12;51543:8;51491:21;:61::i;:::-;-1:-1:-1;;;;;51829:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;51888:49:0;;-1:-1:-1;;;;;51829:44:0;;;;;;;51888:49;;;;-1:-1:-1;;51829:44:0;;;;;;51888:49;;;;;;;;;;;;;;;;51954:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;52004:66:0;;;-1:-1:-1;;;52054:15:0;52004:66;;;;;;;;;;;;;51954:25;;52151:23;;;;19020:19;:23;52191:822;;52231:504;52262:38;;52287:12;;-1:-1:-1;;;;;52262:38:0;;;52279:1;;52262:38;;52279:1;;52262:38;52354:212;52423:1;52456:2;52489:14;;;;;;52534:5;52354:30;:212::i;:::-;52323:365;;52624:40;;-1:-1:-1;;;52624:40:0;;;;;;;;;;;52323:365;52730:3;52715:12;:18;52231:504;;52816:12;52799:13;;:29;52795:43;;52830:8;;;52795:43;52191:822;;;52879:119;52910:40;;52935:14;;;;;-1:-1:-1;;;;;52910:40:0;;;52927:1;;52910:40;;52927:1;;52910:40;52993:3;52978:12;:18;52879:119;;52191:822;-1:-1:-1;53027:13:0;:28;;;53077:60;;53110:2;53114:12;53128:8;53077:60;:::i;8524:149::-;8587:7;8618:1;8614;:5;:51;;8776:13;8875:15;;;8911:4;8904:15;;;8958:4;8942:21;;8614:51;;;8776:13;8875:15;;;8911:4;8904:15;;;8958:4;8942:21;;8622:20;8607:58;8524:149;-1:-1:-1;;;8524:149:0:o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:406:1;78:5;-1:-1:-1;;;;;104:6:1;101:30;98:2;;;134:18;;:::i;:::-;172:57;217:2;196:15;;-1:-1:-1;;192:29:1;223:4;188:40;172:57;:::i;:::-;163:66;;252:6;245:5;238:21;292:3;283:6;278:3;274:16;271:25;268:2;;;309:1;306;299:12;268:2;358:6;353:3;346:4;339:5;335:16;322:43;412:1;405:4;396:6;389:5;385:18;381:29;374:40;88:332;;;;;:::o;425:173::-;493:20;;-1:-1:-1;;;;;542:31:1;;532:42;;522:2;;588:1;585;578:12;522:2;474:124;;;:::o;603:395::-;666:8;676:6;730:3;723:4;715:6;711:17;707:27;697:2;;755:8;745;738:26;697:2;-1:-1:-1;785:20:1;;-1:-1:-1;;;;;817:30:1;;814:2;;;867:8;857;850:26;814:2;911:4;903:6;899:17;887:29;;971:3;964:4;954:6;951:1;947:14;939:6;935:27;931:38;928:47;925:2;;;988:1;985;978:12;925:2;687:311;;;;;:::o;1003:196::-;1062:6;1115:2;1103:9;1094:7;1090:23;1086:32;1083:2;;;1136:6;1128;1121:22;1083:2;1164:29;1183:9;1164:29;:::i;1204:270::-;1272:6;1280;1333:2;1321:9;1312:7;1308:23;1304:32;1301:2;;;1354:6;1346;1339:22;1301:2;1382:29;1401:9;1382:29;:::i;:::-;1372:39;;1430:38;1464:2;1453:9;1449:18;1430:38;:::i;:::-;1420:48;;1291:183;;;;;:::o;1479:338::-;1556:6;1564;1572;1625:2;1613:9;1604:7;1600:23;1596:32;1593:2;;;1646:6;1638;1631:22;1593:2;1674:29;1693:9;1674:29;:::i;:::-;1664:39;;1722:38;1756:2;1745:9;1741:18;1722:38;:::i;:::-;1712:48;;1807:2;1796:9;1792:18;1779:32;1769:42;;1583:234;;;;;:::o;1822:696::-;1917:6;1925;1933;1941;1994:3;1982:9;1973:7;1969:23;1965:33;1962:2;;;2016:6;2008;2001:22;1962:2;2044:29;2063:9;2044:29;:::i;:::-;2034:39;;2092:38;2126:2;2115:9;2111:18;2092:38;:::i;:::-;2082:48;;2177:2;2166:9;2162:18;2149:32;2139:42;;2232:2;2221:9;2217:18;2204:32;-1:-1:-1;;;;;2251:6:1;2248:30;2245:2;;;2296:6;2288;2281:22;2245:2;2324:22;;2377:4;2369:13;;2365:27;-1:-1:-1;2355:2:1;;2411:6;2403;2396:22;2355:2;2439:73;2504:7;2499:2;2486:16;2481:2;2477;2473:11;2439:73;:::i;:::-;2429:83;;;1952:566;;;;;;;:::o;2523:325::-;2588:6;2596;2649:2;2637:9;2628:7;2624:23;2620:32;2617:2;;;2670:6;2662;2655:22;2617:2;2698:29;2717:9;2698:29;:::i;:::-;2688:39;;2777:2;2766:9;2762:18;2749:32;2790:28;2812:5;2790:28;:::i;:::-;2837:5;2827:15;;;2607:241;;;;;:::o;2853:264::-;2921:6;2929;2982:2;2970:9;2961:7;2957:23;2953:32;2950:2;;;3003:6;2995;2988:22;2950:2;3031:29;3050:9;3031:29;:::i;:::-;3021:39;3107:2;3092:18;;;;3079:32;;-1:-1:-1;;;2940:177:1:o;3122:1084::-;3215:6;3223;3276:2;3264:9;3255:7;3251:23;3247:32;3244:2;;;3297:6;3289;3282:22;3244:2;3342:9;3329:23;-1:-1:-1;;;;;3412:2:1;3404:6;3401:14;3398:2;;;3433:6;3425;3418:22;3398:2;3476:6;3465:9;3461:22;3451:32;;3521:7;3514:4;3510:2;3506:13;3502:27;3492:2;;3548:6;3540;3533:22;3492:2;3589;3576:16;3611:4;3634:2;3630;3627:10;3624:2;;;3640:18;;:::i;:::-;3686:2;3683:1;3679:10;3669:20;;3709:28;3733:2;3729;3725:11;3709:28;:::i;:::-;3771:15;;;3802:12;;;;3834:11;;;3864;;;3860:20;;3857:33;-1:-1:-1;3854:2:1;;;3908:6;3900;3893:22;3854:2;3935:6;3926:15;;3950:169;3964:2;3961:1;3958:9;3950:169;;;4021:23;4040:3;4021:23;:::i;:::-;4009:36;;3982:1;3975:9;;;;;4065:12;;;;4097;;3950:169;;;-1:-1:-1;4138:5:1;-1:-1:-1;4162:38:1;;-1:-1:-1;4181:18:1;;;4162:38;:::i;:::-;4152:48;;;;;;3234:972;;;;;:::o;4211:457::-;4297:6;4305;4358:2;4346:9;4337:7;4333:23;4329:32;4326:2;;;4379:6;4371;4364:22;4326:2;4424:9;4411:23;-1:-1:-1;;;;;4449:6:1;4446:30;4443:2;;;4494:6;4486;4479:22;4443:2;4538:70;4600:7;4591:6;4580:9;4576:22;4538:70;:::i;:::-;4627:8;;4512:96;;-1:-1:-1;4316:352:1;-1:-1:-1;;;;4316:352:1:o;4673:803::-;4795:6;4803;4811;4819;4872:2;4860:9;4851:7;4847:23;4843:32;4840:2;;;4893:6;4885;4878:22;4840:2;4938:9;4925:23;-1:-1:-1;;;;;5008:2:1;5000:6;4997:14;4994:2;;;5029:6;5021;5014:22;4994:2;5073:70;5135:7;5126:6;5115:9;5111:22;5073:70;:::i;:::-;5162:8;;-1:-1:-1;5047:96:1;-1:-1:-1;5250:2:1;5235:18;;5222:32;;-1:-1:-1;5266:16:1;;;5263:2;;;5300:6;5292;5285:22;5263:2;;5344:72;5408:7;5397:8;5386:9;5382:24;5344:72;:::i;:::-;4830:646;;;;-1:-1:-1;5435:8:1;-1:-1:-1;;;;4830:646:1:o;5943:251::-;5999:6;6052:2;6040:9;6031:7;6027:23;6023:32;6020:2;;;6073:6;6065;6058:22;6020:2;6117:9;6104:23;6136:28;6158:5;6136:28;:::i;6199:255::-;6266:6;6319:2;6307:9;6298:7;6294:23;6290:32;6287:2;;;6340:6;6332;6325:22;6287:2;6377:9;6371:16;6396:28;6418:5;6396:28;:::i;6459:657::-;6533:6;6541;6549;6557;6610:3;6598:9;6589:7;6585:23;6581:33;6578:2;;;6632:6;6624;6617:22;6578:2;6676:9;6663:23;6695:28;6717:5;6695:28;:::i;:::-;6742:5;-1:-1:-1;6799:2:1;6784:18;;6771:32;6812:30;6771:32;6812:30;:::i;:::-;6861:7;-1:-1:-1;6920:2:1;6905:18;;6892:32;6933:30;6892:32;6933:30;:::i;:::-;6982:7;-1:-1:-1;7041:2:1;7026:18;;7013:32;7054:30;7013:32;7054:30;:::i;:::-;6568:548;;;;-1:-1:-1;6568:548:1;;-1:-1:-1;;6568:548:1:o;7121:264::-;7189:6;7197;7250:2;7238:9;7229:7;7225:23;7221:32;7218:2;;;7271:6;7263;7256:22;7218:2;7312:9;7299:23;7289:33;;7341:38;7375:2;7364:9;7360:18;7341:38;:::i;7390:258::-;7458:6;7466;7519:2;7507:9;7498:7;7494:23;7490:32;7487:2;;;7540:6;7532;7525:22;7487:2;-1:-1:-1;;7568:23:1;;;7638:2;7623:18;;;7610:32;;-1:-1:-1;7477:171:1:o;7653:255::-;7711:6;7764:2;7752:9;7743:7;7739:23;7735:32;7732:2;;;7785:6;7777;7770:22;7732:2;7829:9;7816:23;7848:30;7872:5;7848:30;:::i;7913:259::-;7982:6;8035:2;8023:9;8014:7;8010:23;8006:32;8003:2;;;8056:6;8048;8041:22;8003:2;8093:9;8087:16;8112:30;8136:5;8112:30;:::i;8177:480::-;8246:6;8299:2;8287:9;8278:7;8274:23;8270:32;8267:2;;;8320:6;8312;8305:22;8267:2;8365:9;8352:23;-1:-1:-1;;;;;8390:6:1;8387:30;8384:2;;;8435:6;8427;8420:22;8384:2;8463:22;;8516:4;8508:13;;8504:27;-1:-1:-1;8494:2:1;;8550:6;8542;8535:22;8494:2;8578:73;8643:7;8638:2;8625:16;8620:2;8616;8612:11;8578:73;:::i;8662:190::-;8721:6;8774:2;8762:9;8753:7;8749:23;8745:32;8742:2;;;8795:6;8787;8780:22;8742:2;-1:-1:-1;8823:23:1;;8732:120;-1:-1:-1;8732:120:1:o;8857:194::-;8927:6;8980:2;8968:9;8959:7;8955:23;8951:32;8948:2;;;9001:6;8993;8986:22;8948:2;-1:-1:-1;9029:16:1;;8938:113;-1:-1:-1;8938:113:1:o;9325:326::-;9402:6;9410;9418;9471:2;9459:9;9450:7;9446:23;9442:32;9439:2;;;9492:6;9484;9477:22;9439:2;-1:-1:-1;;9520:23:1;;;9590:2;9575:18;;9562:32;;-1:-1:-1;9641:2:1;9626:18;;;9613:32;;9429:222;-1:-1:-1;9429:222:1:o;9656:395::-;9742:6;9750;9758;9766;9819:3;9807:9;9798:7;9794:23;9790:33;9787:2;;;9841:6;9833;9826:22;9787:2;-1:-1:-1;;9869:23:1;;;9939:2;9924:18;;9911:32;;-1:-1:-1;9990:2:1;9975:18;;9962:32;;10041:2;10026:18;10013:32;;-1:-1:-1;9777:274:1;-1:-1:-1;9777:274:1:o;10056:257::-;10097:3;10135:5;10129:12;10162:6;10157:3;10150:19;10178:63;10234:6;10227:4;10222:3;10218:14;10211:4;10204:5;10200:16;10178:63;:::i;:::-;10295:2;10274:15;-1:-1:-1;;10270:29:1;10261:39;;;;10302:4;10257:50;;10105:208;-1:-1:-1;;10105:208:1:o;10318:185::-;10360:3;10398:5;10392:12;10413:52;10458:6;10453:3;10446:4;10439:5;10435:16;10413:52;:::i;:::-;10481:16;;;;;10368:135;-1:-1:-1;;10368:135:1:o;10745:229::-;10894:2;10890:15;;;;-1:-1:-1;;10886:53:1;10874:66;;10965:2;10956:12;;10864:110::o;10979:1437::-;11357:3;11386;11421:6;11415:13;11451:3;11473:1;11501:9;11497:2;11493:18;11483:28;;11561:2;11550:9;11546:18;11583;11573:2;;11627:4;11619:6;11615:17;11605:27;;11573:2;11653;11701;11693:6;11690:14;11670:18;11667:38;11664:2;;;-1:-1:-1;;;11728:33:1;;11784:4;11781:1;11774:15;11814:4;11735:3;11802:17;11664:2;11845:18;11872:104;;;;11990:1;11985:322;;;;11838:469;;11872:104;-1:-1:-1;;11905:24:1;;11893:37;;11950:16;;;;-1:-1:-1;11872:104:1;;11985:322;21111:4;21130:17;;;21180:4;21164:21;;12080:3;12096:165;12110:6;12107:1;12104:13;12096:165;;;12188:14;;12175:11;;;12168:35;12231:16;;;;12125:10;;12096:165;;;12100:3;;12290:6;12285:3;12281:16;12274:23;;11838:469;;;;;;;12323:87;12348:61;12374:34;12404:3;-1:-1:-1;;;10691:16:1;;10732:1;10723:11;;10681:59;12374:34;12366:6;12348:61;:::i;:::-;-1:-1:-1;;;10568:20:1;;10613:1;10604:11;;10558:63;12323:87;12316:94;11365:1051;-1:-1:-1;;;;;11365:1051:1:o;12629:488::-;-1:-1:-1;;;;;12898:15:1;;;12880:34;;12950:15;;12945:2;12930:18;;12923:43;12997:2;12982:18;;12975:34;;;13045:3;13040:2;13025:18;;13018:31;;;12823:4;;13066:45;;13091:19;;13083:6;13066:45;:::i;:::-;13058:53;12832:285;-1:-1:-1;;;;;;12832:285:1:o;14818:219::-;14967:2;14956:9;14949:21;14930:4;14987:44;15027:2;15016:9;15012:18;15004:6;14987:44;:::i;15042:346::-;15244:2;15226:21;;;15283:2;15263:18;;;15256:30;-1:-1:-1;;;15317:2:1;15302:18;;15295:52;15379:2;15364:18;;15216:172::o;15393:351::-;15595:2;15577:21;;;15634:2;15614:18;;;15607:30;15673:29;15668:2;15653:18;;15646:57;15735:2;15720:18;;15567:177::o;16512:398::-;16714:2;16696:21;;;16753:2;16733:18;;;16726:30;16792:34;16787:2;16772:18;;16765:62;-1:-1:-1;;;16858:2:1;16843:18;;16836:32;16900:3;16885:19;;16686:224::o;17998:345::-;18200:2;18182:21;;;18239:2;18219:18;;;18212:30;-1:-1:-1;;;18273:2:1;18258:18;;18251:51;18334:2;18319:18;;18172:171::o;18701:409::-;18903:2;18885:21;;;18942:2;18922:18;;;18915:30;18981:34;18976:2;18961:18;;18954:62;-1:-1:-1;;;19047:2:1;19032:18;;19025:43;19100:3;19085:19;;18875:235::o;19115:355::-;19317:2;19299:21;;;19356:2;19336:18;;;19329:30;19395:33;19390:2;19375:18;;19368:61;19461:2;19446:18;;19289:181::o;19475:402::-;19677:2;19659:21;;;19716:2;19696:18;;;19689:30;19755:34;19750:2;19735:18;;19728:62;-1:-1:-1;;;19821:2:1;19806:18;;19799:36;19867:3;19852:19;;19649:228::o;20784:275::-;20855:2;20849:9;20920:2;20901:13;;-1:-1:-1;;20897:27:1;20885:40;;-1:-1:-1;;;;;20940:34:1;;20976:22;;;20937:62;20934:2;;;21002:18;;:::i;:::-;21038:2;21031:22;20829:230;;-1:-1:-1;20829:230:1:o;21196:128::-;21236:3;21267:1;21263:6;21260:1;21257:13;21254:2;;;21273:18;;:::i;:::-;-1:-1:-1;21309:9:1;;21244:80::o;21329:120::-;21369:1;21395;21385:2;;21400:18;;:::i;:::-;-1:-1:-1;21434:9:1;;21375:74::o;21454:125::-;21494:4;21522:1;21519;21516:8;21513:2;;;21527:18;;:::i;:::-;-1:-1:-1;21564:9:1;;21503:76::o;21584:258::-;21656:1;21666:113;21680:6;21677:1;21674:13;21666:113;;;21756:11;;;21750:18;21737:11;;;21730:39;21702:2;21695:10;21666:113;;;21797:6;21794:1;21791:13;21788:2;;;-1:-1:-1;;21832:1:1;21814:16;;21807:27;21637:205::o;21847:380::-;21926:1;21922:12;;;;21969;;;21990:2;;22044:4;22036:6;22032:17;22022:27;;21990:2;22097;22089:6;22086:14;22066:18;22063:38;22060:2;;;22143:10;22138:3;22134:20;22131:1;22124:31;22178:4;22175:1;22168:15;22206:4;22203:1;22196:15;22060:2;;21902:325;;;:::o;22232:135::-;22271:3;-1:-1:-1;;22292:17:1;;22289:2;;;22312:18;;:::i;:::-;-1:-1:-1;22359:1:1;22348:13;;22279:88::o;22372:175::-;22409:3;22453:4;22446:5;22442:16;22482:4;22473:7;22470:17;22467:2;;;22490:18;;:::i;:::-;22539:1;22526:15;;22417:130;-1:-1:-1;;22417:130:1:o;22552:112::-;22584:1;22610;22600:2;;22615:18;;:::i;:::-;-1:-1:-1;22649:9:1;;22590:74::o;22669:127::-;22730:10;22725:3;22721:20;22718:1;22711:31;22761:4;22758:1;22751:15;22785:4;22782:1;22775:15;22801:127;22862:10;22857:3;22853:20;22850:1;22843:31;22893:4;22890:1;22883:15;22917:4;22914:1;22907:15;22933:127;22994:10;22989:3;22985:20;22982:1;22975:31;23025:4;23022:1;23015:15;23049:4;23046:1;23039:15;23065:118;23151:5;23144:13;23137:21;23130:5;23127:32;23117:2;;23173:1;23170;23163:12;23188:131;-1:-1:-1;;;;;;23262:32:1;;23252:43;;23242:2;;23309:1;23306;23299:12

ipfs://ffed313abf40aaff826ea66c3da7e610a4bb97abf5e4a2e00a3fef709a1a59c6