Token

NUO (NUO)

ERC-721

Overview

Max Total Supply

887 NUO

Holders

608

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x614db8e99ef30b36d3e06787510f19a770e2e02f

Filtered by Token Holder

0xA287059da18eBf2205798EBec1DEA36a5c1C67C9

Balance

10 NUO

0xA287059da18eBf2205798EBec1DEA36a5c1C67C9

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

NUO

Compiler Version

v0.8.4+commit.c7e474f2

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

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

pragma solidity 0.8.4;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// OpenZeppelin Contracts (last updated v4.8.0) (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() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

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

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

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

// 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.8.0) (utils/math/Math.sol)
/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)
/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

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

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

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

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

// 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.8.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
            functionCallWithValue(
                target,
                data,
                0,
                "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"
        );
        (bool success, bytes memory returndata) = target.call{value: value}(
            data
        );
        return
            verifyCallResultFromTarget(
                target,
                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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return
            verifyCallResultFromTarget(
                target,
                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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return
            verifyCallResultFromTarget(
                target,
                success,
                returndata,
                errorMessage
            );
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage)
        private
        pure
    {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(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.8.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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * 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 NUO 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 = 0;

    uint256 private _preMintLimit = 0;

    uint256 private _publicMintLimit = 0;

    uint256 private _superMintLimit = 1000;

    uint256 private _addressMintLimit = 0;

    uint256 private _kycMintCount;

    uint256 private _preMintCount;

    uint256 private _publicMintCount;

    uint256 private _superMintCount;

    uint256 private _kycMintPrice = 0;

    uint256 private _preMintPrice = 0;

    uint256 private _publicMintPrice = 0;

    bool private _kycMintOpen = false;

    bool private _preMintOpen = false;

    bool private _publicMintOpen = false;

    bool private _superMintOpen = false;

    uint256 _totalSupply = 2006;

    uint256 _totalTokens;

    bool private _transferOpen = false;

    string private _nftName = "NUO";
    string private _baseUri =
        "ipfs://QmVDNBSAEe996o9mAHaZLa5bqK726FovEehdwJeFYYDc6Q";

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

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

    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,
        uint256 superMintLimit
    ) public onlyOperator {
        _kycMintLimit = kycMintLimit;
        _preMintLimit = preMintLimit;
        _publicMintLimit = publicMintLimit;
        _addressMintLimit = addressMintLimit;
        _superMintLimit = superMintLimit;
    }

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

    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,
        bool superMintOpen
    ) public onlyOperator {
        _kycMintOpen = kycMintOpen;
        _preMintOpen = preMintOpen;
        _publicMintOpen = publicMintOpen;
        _transferOpen = transferOpen;
        _superMintOpen = superMintOpen;
    }

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

    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, uint256 count)
        public
        payable
        nonReentrant
    {
        require(count >= 1, "error:10010 Must be greater than 1");

        require(
            msg.value == _kycMintPrice * count,
            "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"
        );

        for (uint256 i = 0; i < count; i++) {
            require(
                _kycMintCount < _kycMintLimit,
                "error:10004 Reach the limit"
            );

            _handleMint(_msgSender());

            _kycMintCount = _kycMintCount + 1;
        }
    }

    function preMint(bytes32[] calldata merkleProof, uint256 count)
        public
        payable
        nonReentrant
    {
        require(count >= 1, "error:10010 Must be greater than 1");

        require(
            msg.value == _preMintPrice * count,
            "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"
        );

        for (uint256 i = 0; i < count; i++) {
            require(
                _preMintCount < _preMintLimit,
                "error:10004 Reach the limit"
            );

            _handleMint(_msgSender());

            _preMintCount = _preMintCount + 1;
        }
    }

    function publicMint(uint256 count) public payable nonReentrant {
        require(count >= 1, "error:10010 Must be greater than 1");

        require(
            msg.value == _publicMintPrice * count,
            "error:10000 msg.value is incorrect"
        );

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

        for (uint256 i = 0; i < count; i++) {
            require(
                _publicMintCount < _publicMintLimit,
                "error:10004 Reach the limit"
            );

            _handleMint(_msgSender());

            _publicMintCount = _publicMintCount + 1;
        }
    }

    function operatorMint(
        address[] memory toAddresses,
        uint256[] memory amounts
    ) public onlyOperator {
        require(
            toAddresses.length == amounts.length,
            "error:10033 toAddresses length does not match amounts length"
        );

        uint256 _len = toAddresses.length;
        for (uint256 _i; _i < _len; _i++) {
            address to = toAddresses[_i];
            uint256 amount = amounts[_i];

            for (uint256 j = 0; j < amount; j++) {
                require(
                    _totalTokens < _totalSupply,
                    "error:10010 Exceeding the total amount"
                );

                _safeMint(to, 1);

                _totalTokens = _totalTokens + 1;
            }
        }
    }

    function getCanMintCount(address user) external view returns (uint256) {
        return _addressMintLimit - addressMintCount[user];
    }

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

    mapping(address => mapping(uint256 => uint256)) private superAddressToken;

    uint256 private _superMintPrice = 0;

    function setSuperMintPrice(uint256 superMintPrice) public onlyOperator {
        _superMintPrice = superMintPrice;
    }

    function getSuperMintPrice() public view returns (uint256) {
        return _superMintPrice;
    }

    mapping(address => uint256) private superAddress;

    function setSuperAddress(address contractAddress, uint256 count)
        public
        onlyOperator
    {
        superAddress[contractAddress] = count;
    }

    function getSuperAddress(address contractAddress)
        public
        view
        returns (uint256)
    {
        return superAddress[contractAddress];
    }

    function getTokenCanMintCount(address contractAddress, uint256 tokenId)
        public
        view
        returns (uint256)
    {
        if (superAddress[contractAddress] == 0) {
            return 0;
        }
        return
            superAddress[contractAddress] -
            superAddressToken[contractAddress][tokenId];
    }

    function superMint(
        address[] memory contracts,
        uint256[] memory tokenIds,
        uint256[] memory counts
    ) public payable nonReentrant {
        require(
            contracts.length == tokenIds.length,
            "error: 10000 contracts length does not match tokenIds length"
        );

        require(
            tokenIds.length == counts.length,
            "error: 10001 tokenIds length does not match counts length"
        );

        require(_superMintOpen, "error:10002 switch off");

        uint256 totalMintCount = 0;
        for (uint256 i = 0; i < tokenIds.length; i++) {
            totalMintCount = totalMintCount + counts[i];
        }

        require(totalMintCount < 30, "error: 10003 Limit 30");

        require(
            msg.value == _superMintPrice * totalMintCount,
            "error:10004 msg.value is incorrect"
        );

        for (uint256 i = 0; i < tokenIds.length; i++) {
            address contractAddress = contracts[i];
            uint256 tokenId = tokenIds[i];
            uint256 mintCount = counts[i];

            require(
                IERC721(contractAddress).ownerOf(tokenId) == msg.sender,
                "error:10005 No owner"
            );

            require(
                superAddress[contractAddress] > 0,
                "error:10006 Contract cannot mint"
            );

            require(
                superAddressToken[contractAddress][tokenId] + mintCount <=
                    superAddress[contractAddress],
                "error:10007 Greater than maximum quantity"
            );

            require(
                _totalTokens + mintCount <= _totalSupply,
                "error:10008 Exceeding the total amount"
            );

            require(
                _superMintCount + mintCount <= _superMintLimit,
                "error:10009 Reach the limit"
            );

            for (uint256 j = 0; j < mintCount; j++) {
                _safeMint(msg.sender, 1);
            }

            _superMintCount = _superMintCount + mintCount;

            _totalTokens = _totalTokens + mintCount;

            superAddressToken[contractAddress][tokenId] =
                superAddressToken[contractAddress][tokenId] +
                mintCount;
        }
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"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":[{"internalType":"address","name":"user","type":"address"}],"name":"getCanMintCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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"},{"internalType":"uint256","name":"superMintCount","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"},{"internalType":"uint256","name":"superMintLimit","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":[{"internalType":"address","name":"contractAddress","type":"address"}],"name":"getSuperAddress","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSuperMintPrice","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"},{"internalType":"bool","name":"superMintOpen","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getTokenCanMintCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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[]"},{"internalType":"uint256","name":"count","type":"uint256"}],"name":"kycMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"toAddresses","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"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[]"},{"internalType":"uint256","name":"count","type":"uint256"}],"name":"preMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"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"},{"internalType":"uint256","name":"superMintLimit","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":"address","name":"contractAddress","type":"address"},{"internalType":"uint256","name":"count","type":"uint256"}],"name":"setSuperAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"superMintPrice","type":"uint256"}],"name":"setSuperMintPrice","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"},{"internalType":"bool","name":"superMintOpen","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":[{"internalType":"address[]","name":"contracts","type":"address[]"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"uint256[]","name":"counts","type":"uint256[]"}],"name":"superMint","outputs":[],"stateMutability":"payable","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"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

85250:17302:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58802:355;;;;;;;;;;-1:-1:-1;58802:355:0;;;;;:::i;:::-;;:::i;:::-;;;16678:14:1;;16671:22;16653:41;;16641:2;16626:18;58802:355:0;;;;;;;;97898:86;;;;;;;;;;-1:-1:-1;97964:12:0;;97898:86;;;17976:25:1;;;17964:2;17949:18;97898:86:0;17931:76:1;62088:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;63711:245::-;;;;;;;;;;-1:-1:-1;63711:245:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;15697:32:1;;;15679:51;;15667:2;15652:18;63711:245:0;15634:102:1;63251:394:0;;;;;;;;;;-1:-1:-1;63251:394:0;;;;;:::i;:::-;;:::i;:::-;;99851:346;;;;;;;;;;-1:-1:-1;99851:346:0;;;;;:::i;:::-;;:::i;94939:610::-;;;;;;;;;;-1:-1:-1;94939:610:0;;;;;:::i;:::-;;:::i;98091:444::-;;;;;;;;;;-1:-1:-1;98091:444:0;;;;;:::i;:::-;;:::i;90663:929::-;;;;;;:::i;:::-;;:::i;85321:33::-;;;;;;;;;;;;;;;;58042:312;;;;;;;;;;-1:-1:-1;58305:12:0;;58095:7;58289:13;:28;58042:312;;87799:434;;;;;;;;;;-1:-1:-1;87799:434:0;;;;;:::i;:::-;;:::i;64699:170::-;;;;;;;;;;-1:-1:-1;64699:170:0;;;;;:::i;:::-;;:::i;85361:33::-;;;;;;;;;;;;;;;;92537:633;;;;;;:::i;:::-;;:::i;88742:276::-;;;;;;;;;;-1:-1:-1;88742:276:0;;;;;:::i;:::-;;:::i;64940:185::-;;;;;;;;;;-1:-1:-1;64940:185:0;;;;;:::i;:::-;;:::i;99504:164::-;;;;;;;;;;-1:-1:-1;99504:164:0;;;;;:::i;:::-;;:::i;96170:507::-;;;;;;;;;;-1:-1:-1;96170:507:0;;;;;:::i;:::-;;:::i;88241:493::-;;;;;;;;;;-1:-1:-1;88539:13:0;;88578;;88620:16;;88666:17;;88711:15;;88241:493;;;28911:25:1;;;28967:2;28952:18;;28945:34;;;;28995:18;;;28988:34;;;;29053:2;29038:18;;29031:34;29096:3;29081:19;;29074:35;28898:3;28883:19;88241:493:0;28865:250:1;89361:391:0;;;;;;;;;;-1:-1:-1;89361:391:0;;;;;:::i;:::-;;:::i;61896:125::-;;;;;;;;;;-1:-1:-1;61896:125:0;;;;;:::i;:::-;;:::i;80508:130::-;;;;;;;;;;-1:-1:-1;80508:130:0;;;;;:::i;:::-;;:::i;99676:167::-;;;;;;;;;;-1:-1:-1;99676:167:0;;;;;:::i;:::-;-1:-1:-1;;;;;99806:29:0;99774:7;99806:29;;;:12;:29;;;;;;;99676:167;59221:206;;;;;;;;;;-1:-1:-1;59221:206:0;;;;;:::i;:::-;;:::i;30623:103::-;;;;;;;;;;;;;:::i;87022:226::-;;;;;;;;;;-1:-1:-1;87022:226:0;;;;;:::i;:::-;;:::i;94541:116::-;;;;;;;;;;-1:-1:-1;94541:116:0;;;;;:::i;:::-;94601:7;94628:21;;;:12;:21;;;;;;;94541:116;87256:535;;;;;;;;;;-1:-1:-1;87256:535:0;;;;;:::i;:::-;;:::i;:::-;;;;16892:14:1;;16885:22;16867:41;;16951:14;;16944:22;16939:2;16924:18;;16917:50;16840:18;87256:535:0;16822:151:1;29975:87:0;;;;;;;;;;-1:-1:-1;30048:6:0;;-1:-1:-1;;;;;30048:6:0;29975:87;;86607:407;;;;;;;;;;-1:-1:-1;86866:13:0;;86905;;86947:16;;86991:15;;86607:407;;;28487:25:1;;;28543:2;28528:18;;28521:34;;;;28571:18;;;28564:34;28629:2;28614:18;;28607:34;28474:3;28459:19;86607:407:0;28441:206:1;79289:180:0;;;;;;;;;;-1:-1:-1;79289:180:0;;;;;:::i;:::-;;:::i;62257:104::-;;;;;;;;;;;;;:::i;80763:120::-;;;;;;;;;;-1:-1:-1;80763:120:0;;;;;:::i;:::-;;:::i;96727:305::-;;;;;;;;;;-1:-1:-1;96727:305:0;;;;;:::i;:::-;;:::i;97555:100::-;;;;;;;;;;-1:-1:-1;97555:100:0;;;;;:::i;:::-;;:::i;64028:319::-;;;;;;;;;;-1:-1:-1;64028:319:0;;;;;:::i;:::-;;:::i;97992:91::-;;;;;;;;;;-1:-1:-1;98063:12:0;;97992:91;;89026:327;;;;;;;;;;-1:-1:-1;89248:13:0;;89287;;89329:16;;89026:327;;;28134:25:1;;;28190:2;28175:18;;28168:34;;;;28218:18;;;28211:34;28122:2;28107:18;89026:327:0;28089:162:1;89760:450:0;;;;;;;;;;-1:-1:-1;90030:12:0;;90148:13;;89760:450;;;90030:12;;;;17232:14:1;17225:22;17207:41;;90030:12:0;90067;;;;17291:14:1;17284:22;17279:2;17264:18;;17257:50;90107:15:0;;;;;17350:14:1;17343:22;17323:18;;;17316:50;;;;90148:13:0;;;17409:14:1;17402:22;17397:2;17382:18;;17375:50;90188:14:0;;;;;;;17469::1;17462:22;17456:3;17441:19;;17434:51;17194:3;17179:19;89760:450:0;17161:330:1;95557:605:0;;;;;;;;;;-1:-1:-1;95557:605:0;;;;;:::i;:::-;;:::i;94665:29::-;;;;;;;;;;-1:-1:-1;94665:29:0;;;;;;;;99209:122;;;;;;;;;;-1:-1:-1;99209:122:0;;;;;:::i;:::-;;:::i;94125:408::-;;;;;;;;;;-1:-1:-1;94125:408:0;;;;;:::i;:::-;;:::i;:::-;;;;17717:14:1;;17710:22;17692:41;;17764:2;17749:18;;17742:34;;;;17792:18;;;17785:34;17680:2;17665:18;94125:408:0;17647:178:1;65196:392:0;;;;;;;;;;-1:-1:-1;65196:392:0;;;;;:::i;:::-;;:::i;91600:929::-;;;;;;:::i;:::-;;:::i;97663:227::-;;;;;;;;;;-1:-1:-1;97663:227:0;;;;;:::i;:::-;;:::i;93178:792::-;;;;;;;;;;-1:-1:-1;93178:792:0;;;;;:::i;:::-;;:::i;94703:90::-;;;;;;;;;;-1:-1:-1;94703:90:0;;;;;:::i;:::-;;:::i;99339:100::-;;;;;;;;;;-1:-1:-1;99416:15:0;;99339:100;;64418:214;;;;;;;;;;-1:-1:-1;64418:214:0;;;;;:::i;:::-;-1:-1:-1;;;;;64589:25:0;;;64560:4;64589:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;64418:214;93978:139;;;;;;;;;;-1:-1:-1;93978:139:0;;;;;:::i;:::-;;:::i;100205:2344::-;;;;;;:::i;:::-;;:::i;30881:238::-;;;;;;;;;;-1:-1:-1;30881:238:0;;;;;:::i;:::-;;:::i;79214:66::-;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;79214:66:0;;80891:124;;;;;;;;;;-1:-1:-1;80891:124:0;;;;;:::i;:::-;;:::i;58802:355::-;58949:4;-1:-1:-1;;;;;;58991:40:0;;-1:-1:-1;;;58991:40:0;;:105;;-1:-1:-1;;;;;;;59048:48:0;;-1:-1:-1;;;59048:48:0;58991:105;:158;;;-1:-1:-1;;;;;;;;;;55983:40:0;;;59113:36;58971:178;58802:355;-1:-1:-1;;58802:355:0:o;62088:100::-;62142:13;62175:5;62168:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62088:100;:::o;63711:245::-;63815:7;63845:16;63853:7;63845;:16::i;:::-;63840:64;;63870:34;;-1:-1:-1;;;63870:34:0;;;;;;;;;;;63840:64;-1:-1:-1;63924:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;63924:24:0;;63711:245::o;63251:394::-;63324:13;63340:24;63356:7;63340:15;:24::i;:::-;63324:40;;63385:5;-1:-1:-1;;;;;63379:11:0;:2;-1:-1:-1;;;;;63379:11:0;;63375:48;;;63399:24;;-1:-1:-1;;;63399:24:0;;;;;;;;;;;63375:48;13348:10;-1:-1:-1;;;;;63440:21:0;;;63436:161;;63481:37;63498:5;13348:10;64418:214;:::i;63481:37::-;63476:121;;63546:35;;-1:-1:-1;;;63546:35:0;;;;;;;;;;;63476:121;63609:28;63618:2;63622:7;63631:5;63609:8;:28::i;:::-;63251:394;;;:::o;99851:346::-;-1:-1:-1;;;;;100000:29:0;;99971:7;100000:29;;;:12;:29;;;;;;99996:75;;-1:-1:-1;100058:1:0;100051:8;;99996:75;-1:-1:-1;;;;;100146:34:0;;;;;;:17;:34;;;;;;;;:43;;;;;;;;;100101:29;;;:12;:29;;;;;;:88;;100146:43;100101:88;:::i;:::-;100081:108;99851:346;-1:-1:-1;;;99851:346:0:o;94939:610::-;95011:9;;;;95003:46;;;;-1:-1:-1;;;95003:46:0;;26069:2:1;95003:46:0;;;26051:21:1;26108:2;26088:18;;;26081:30;26147:26;26127:18;;;26120:54;26191:18;;95003:46:0;;;;;;;;;95074:8;95062:9;95100:442;95124:1;95120;:5;95100:442;;;95147:15;95165:8;;95174:1;95165:11;;;;;-1:-1:-1;;;95165:11:0;;;;;;;;;;;;;;;95147:29;;95247:12;13348:10;;13268:98;95247:12;-1:-1:-1;;;;;95217:42:0;:21;95230:7;95217:12;:21::i;:::-;:26;-1:-1:-1;;;;;95217:42:0;;95191:125;;;;-1:-1:-1;;;95191:125:0;;;;;;;:::i;:::-;95333:13;95349:21;;;:12;:21;;;;;;95389:10;95385:146;;95420:21;;;;:12;:21;;;;;;95444:15;95420:39;;;;95483:32;;95444:15;;95433:7;;95483:32;;95420:21;95483:32;95385:146;95100:442;;95127:3;;;;:::i;:::-;;;95100:442;;;;94939:610;;;:::o;98091:444::-;80383:24;13348:10;80508:130;:::i;80383:24::-;80361:119;;;;-1:-1:-1;;;80361:119:0;;;;;;;:::i;:::-;98206:7:::1;98201:236;98219:6;:13;98215:1;:17;;;98201:236;;;98254:12;98276:6;98283:1;98276:9;;;;;;;;-1:-1:-1::0;;;98276:9:0::1;;;;;;;;;;::::0;;::::1;::::0;;;;;;98313:30:::1;::::0;-1:-1:-1;;;98313:30:0;;98337:4:::1;98313:30;::::0;::::1;15679:51:1::0;98276:9:0;;-1:-1:-1;98301:9:0::1;::::0;-1:-1:-1;;;;;98313:15:0;::::1;::::0;::::1;::::0;15652:18:1;;98313:30:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;98301:42:::0;-1:-1:-1;98362:5:0;;98358:68:::1;;98388:22;::::0;-1:-1:-1;;;98388:22:0;;-1:-1:-1;;;;;16426:32:1;;;98388:22:0::1;::::0;::::1;16408:51:1::0;16475:18;;;16468:34;;;98388:14:0;::::1;::::0;::::1;::::0;16381:18:1;;98388:22:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;98358:68;98201:236;;98234:3;;;;;:::i;:::-;;;;98201:236;;;-1:-1:-1::0;98497:30:0::1;::::0;98465:21:::1;::::0;-1:-1:-1;;;;;98497:21:0;::::1;::::0;:30;::::1;;;::::0;98465:21;;98447:15:::1;98497:30:::0;98447:15;98497:30;98465:21;98497;:30;::::1;;;;;;;;;;;;;::::0;::::1;;;;90663:929:::0;12073:21;:19;:21::i;:::-;90815:1:::1;90806:5;:10;;90798:57;;;;-1:-1:-1::0;;;90798:57:0::1;;;;;;;:::i;:::-;90919:5;90903:13;;:21;;;;:::i;:::-;90890:9;:34;90868:118;;;;-1:-1:-1::0;;;90868:118:0::1;;;;;;;:::i;:::-;91007:12;::::0;::::1;;90999:47;;;;-1:-1:-1::0;;;90999:47:0::1;;;;;;;:::i;:::-;91081:158;91118:11;;91081:158;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;91148:18:0::1;::::0;91195:28:::1;::::0;91148:18;;-1:-1:-1;91195:28:0::1;::::0;-1:-1:-1;91212:10:0::1;::::0;91195:28:::1;;;:::i;:::-;;;;;;;;;;;;;91185:39;;;;;;91081:18;:158::i;:::-;91059:240;;;::::0;-1:-1:-1;;;91059:240:0;;22972:2:1;91059:240:0::1;::::0;::::1;22954:21:1::0;;;22991:18;;;22984:30;23050:34;23030:18;;;23023:62;23102:18;;91059:240:0::1;22944:182:1::0;91059:240:0::1;91317:9;91312:273;91336:5;91332:1;:9;91312:273;;;91405:13;;91389;;:29;91363:118;;;;-1:-1:-1::0;;;91363:118:0::1;;;;;;;:::i;:::-;91498:25;13348:10:::0;91498:11:::1;:25::i;:::-;91556:13;::::0;:17:::1;::::0;91572:1:::1;91556:17;:::i;:::-;91540:13;:33:::0;91343:3;::::1;::::0;::::1;:::i;:::-;;;;91312:273;;;;12117:20:::0;11511:1;12637:7;:22;12454:213;87799:434;80383:24;13348:10;80508:130;:::i;80383:24::-;80361:119;;;;-1:-1:-1;;;80361:119:0;;;;;;;:::i;:::-;88023:13:::1;:28:::0;;;;88062:13:::1;:28:::0;;;;88101:16:::1;:34:::0;88146:17:::1;:36:::0;88193:15:::1;:32:::0;87799:434::o;64699:170::-;64833:28;64843:4;64849:2;64853:7;64833:9;:28::i;92537:633::-;12073:21;:19;:21::i;:::-;92628:1:::1;92619:5;:10;;92611:57;;;;-1:-1:-1::0;;;92611:57:0::1;;;;;;;:::i;:::-;92735:5;92716:16;;:24;;;;:::i;:::-;92703:9;:37;92681:121;;;;-1:-1:-1::0;;;92681:121:0::1;;;;;;;:::i;:::-;92823:15;::::0;;;::::1;;;92815:50;;;;-1:-1:-1::0;;;92815:50:0::1;;;;;;;:::i;:::-;92883:9;92878:285;92902:5;92898:1;:9;92878:285;;;92974:16;;92955;;:35;92929:124;;;;-1:-1:-1::0;;;92929:124:0::1;;;;;;;:::i;:::-;93070:25;13348:10:::0;91498:11:::1;:25::i;93070:::-;93131:16;::::0;:20:::1;::::0;93150:1:::1;93131:20;:::i;:::-;93112:16;:39:::0;92909:3;::::1;::::0;::::1;:::i;:::-;;;;92878:285;;;;12117:20:::0;11511:1;12637:7;:22;12454:213;12117:20;92537:633;:::o;88742:276::-;80383:24;13348:10;80508:130;:::i;80383:24::-;80361:119;;;;-1:-1:-1;;;80361:119:0;;;;;;;:::i;:::-;88898:13:::1;:28:::0;;;;88937:13:::1;:28:::0;88976:16:::1;:34:::0;88742:276::o;64940:185::-;65078:39;65095:4;65101:2;65105:7;65078:39;;;;;;;;;;;;:16;:39::i;99504:164::-;80383:24;13348:10;80508:130;:::i;80383:24::-;80361:119;;;;-1:-1:-1;;;80361:119:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;99623:29:0;;::::1;;::::0;;;:12:::1;:29;::::0;;;;:37;99504:164::o;96170:507::-;80383:24;13348:10;80508:130;:::i;80383:24::-;80361:119;;;;-1:-1:-1;;;80361:119:0;;;;;;;:::i;:::-;96292:8;96280:9:::1;96318:352;96342:1;96338;:5;96318:352;;;96365:15;96383:8;;96392:1;96383:11;;;;;-1:-1:-1::0;;;96383:11:0::1;;;;;;;;;;::::0;;::::1;::::0;;;::::1;;96409:13;96425:21:::0;;;:12:::1;:21:::0;;;;;;;;96383:11;;-1:-1:-1;;96465:9:0;;96461:198:::1;;96518:23;96536:5:::0;96518:15:::1;:23;:::i;:::-;96495:19;::::0;;;:10:::1;:19;::::0;;;;:46;;:19;;;:46:::1;::::0;;;::::1;:::i;:::-;::::0;;;-1:-1:-1;;96584:1:0::1;96560:21:::0;;;:12:::1;:21;::::0;;;;;:25;;;96609:34;96627:15:::1;::::0;96573:7;;96609:34:::1;::::0;96584:1;96609:34:::1;96461:198;96318:352;;96345:3;;;;:::i;:::-;;;96318:352;;89361:391:::0;80383:24;13348:10;80508:130;:::i;80383:24::-;80361:119;;;;-1:-1:-1;;;80361:119:0;;;;;;;:::i;:::-;89558:12:::1;:26:::0;;89675:13:::1;:28:::0;;-1:-1:-1;;89675:28:0::1;::::0;::::1;;::::0;;;::::1;::::0;;;-1:-1:-1;;89595:26:0;;;89558;::::1;;-1:-1:-1::0;;89595:26:0;;;;;89558::::1;89595::::0;::::1;;::::0;;;::::1;::::0;;;::::1;-1:-1:-1::0;;89714:30:0;89632:32;;::::1;;::::0;;;::::1;-1:-1:-1::0;;89714:30:0;;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;89361:391::o;61896:125::-;61960:7;61987:21;62000:7;61987:12;:21::i;:::-;:26;;61896:125;-1:-1:-1;;61896:125:0:o;80508:130::-;80575:4;80599:31;-1:-1:-1;;;;;;;;;;;80622:7:0;80599;:31::i;59221:206::-;59285:7;-1:-1:-1;;;;;59309:19:0;;59305:60;;59337:28;;-1:-1:-1;;;59337:28:0;;;;;;;;;;;59305:60;-1:-1:-1;;;;;;59391:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;59391:27:0;;59221:206::o;30623:103::-;29861:13;:11;:13::i;:::-;30688:30:::1;30715:1;30688:18;:30::i;:::-;30623:103::o:0;87022:226::-;80383:24;13348:10;80508:130;:::i;80383:24::-;80361:119;;;;-1:-1:-1;;;80361:119:0;;;;;;;:::i;:::-;87153:18:::1;:38:::0;;;;87202:18:::1;:38:::0;87022:226::o;87256:535::-;87393:19;87414;87463:145;87496:14;;87463:145;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;87525:18:0;;87568:28;;87525:18;;-1:-1:-1;87568:28:0;;-1:-1:-1;87585:10:0;;87568:28;;;:::i;87463:145::-;87446:162;;87638:145;87671:14;;87638:145;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;87700:18:0;;87743:28;;87700:18;;-1:-1:-1;87743:28:0;;-1:-1:-1;87760:10:0;;87743:28;;;:::i;87638:145::-;87621:162;;87256:535;;;;;;;:::o;79289:180::-;79403:4;79432:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;79432:29:0;;;;;;;;;;;;;;;79289:180::o;62257:104::-;62313:13;62346:7;62339:14;;;;;:::i;80763:120::-;80383:24;13348:10;80508:130;:::i;80383:24::-;80361:119;;;;-1:-1:-1;;;80361:119:0;;;;;;;:::i;:::-;80841:34:::1;-1:-1:-1::0;;;;;;;;;;;80867:7:0::1;80841:10;:34::i;96727:305::-:0;13348:10;96864:16;96872:7;96864;:16::i;:::-;-1:-1:-1;;;;;96864:32:0;;96856:66;;;;-1:-1:-1;;;96856:66:0;;;;;;;:::i;:::-;96949:1;96933:13;:17;96961:35;96978:4;96984:2;96988:7;96961:16;:35::i;:::-;-1:-1:-1;;97023:1:0;97007:13;:17;-1:-1:-1;96727:305:0:o;97555:100::-;80383:24;13348:10;80508:130;:::i;80383:24::-;80361:119;;;;-1:-1:-1;;;80361:119:0;;;;;;;:::i;:::-;97629:18;;::::1;::::0;:8:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;:::-;;97555:100:::0;:::o;64028:319::-;-1:-1:-1;;;;;64159:24:0;;13348:10;64159:24;64155:54;;;64192:17;;-1:-1:-1;;;64192:17:0;;;;;;;;;;;64155:54;13348:10;64222:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;64222:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;64222:53:0;;;;;;;;;;64291:48;;16653:41:1;;;64222:42:0;;13348:10;64291:48;;16626:18:1;64291:48:0;;;;;;;64028:319;;:::o;95557:605::-;95635:8;95623:9;95661:494;95685:1;95681;:5;95661:494;;;95708:15;95726:8;;95735:1;95726:11;;;;;-1:-1:-1;;;95726:11:0;;;;;;;;;;;;;;;95708:29;;95808:12;13348:10;;13268:98;95808:12;-1:-1:-1;;;;;95778:42:0;:21;95791:7;95778:12;:21::i;:::-;:26;-1:-1:-1;;;;;95778:42:0;;95752:125;;;;-1:-1:-1;;;95752:125:0;;;;;;;:::i;:::-;95894:13;95910:21;;;:12;:21;;;;;;95950:9;;95946:198;;96003:23;96021:5;96003:15;:23;:::i;:::-;95980:19;;;;:10;:19;;;;;:46;;:19;;;:46;;;;;:::i;:::-;;;;-1:-1:-1;;96069:1:0;96045:21;;;:12;:21;;;;;;:25;;;96094:34;96112:15;;96058:7;;96094:34;;96069:1;96094:34;95946:198;95661:494;;95688:3;;;;:::i;:::-;;;95661:494;;99209:122;80383:24;13348:10;80508:130;:::i;80383:24::-;80361:119;;;;-1:-1:-1;;;80361:119:0;;;;;;;:::i;:::-;99291:15:::1;:32:::0;99209:122::o;94125:408::-;94227:12;94341:21;;;:12;:21;;;;;;94227:12;;;;94377:10;;94373:105;;94414:4;;-1:-1:-1;94443:23:0;94461:5;94443:15;:23;:::i;:::-;94433:33;;94373:105;94506:19;;;;:10;:19;;;;;;94496:29;;:7;:29;:::i;:::-;94125:408;;;;-1:-1:-1;;;94125:408:0:o;65196:392::-;65363:28;65373:4;65379:2;65383:7;65363:9;:28::i;:::-;-1:-1:-1;;;;;65406:13:0;;32920:19;:23;65402:179;;65441:56;65472:4;65478:2;65482:7;65491:5;65441:30;:56::i;:::-;65436:145;;65525:40;;-1:-1:-1;;;65525:40:0;;;;;;;;;;;91600:929;12073:21;:19;:21::i;:::-;91752:1:::1;91743:5;:10;;91735:57;;;;-1:-1:-1::0;;;91735:57:0::1;;;;;;;:::i;:::-;91856:5;91840:13;;:21;;;;:::i;:::-;91827:9;:34;91805:118;;;;-1:-1:-1::0;;;91805:118:0::1;;;;;;;:::i;:::-;91944:12;::::0;::::1;::::0;::::1;;;91936:47;;;;-1:-1:-1::0;;;91936:47:0::1;;;;;;;:::i;:::-;92018:158;92055:11;;92018:158;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;92085:18:0::1;::::0;92132:28:::1;::::0;92085:18;;-1:-1:-1;92132:28:0::1;::::0;-1:-1:-1;92149:10:0::1;::::0;92132:28:::1;;;:::i;92018:158::-;91996:240;;;::::0;-1:-1:-1;;;91996:240:0;;22972:2:1;91996:240:0::1;::::0;::::1;22954:21:1::0;;;22991:18;;;22984:30;23050:34;23030:18;;;23023:62;23102:18;;91996:240:0::1;22944:182:1::0;91996:240:0::1;92254:9;92249:273;92273:5;92269:1;:9;92249:273;;;92342:13;;92326;;:29;92300:118;;;;-1:-1:-1::0;;;92300:118:0::1;;;;;;;:::i;:::-;92435:25;13348:10:::0;91498:11:::1;:25::i;92435:::-;92493:13;::::0;:17:::1;::::0;92509:1:::1;92493:17;:::i;:::-;92477:13;:33:::0;92280:3;::::1;::::0;::::1;:::i;:::-;;;;92249:273;;97663:227:::0;97764:13;97839:8;97854:17;97863:7;97854:8;:17::i;:::-;97822:59;;;;;;;;;:::i;:::-;;;;;;;;;;;;;97795:87;;97663:227;;;:::o;93178:792::-;80383:24;13348:10;80508:130;:::i;80383:24::-;80361:119;;;;-1:-1:-1;;;80361:119:0;;;;;;;:::i;:::-;93356:7:::1;:14;93334:11;:18;:36;93312:146;;;::::0;-1:-1:-1;;;93312:146:0;;24883:2:1;93312:146:0::1;::::0;::::1;24865:21:1::0;24922:2;24902:18;;;24895:30;24961:34;24941:18;;;24934:62;25032:30;25012:18;;;25005:58;25080:19;;93312:146:0::1;24855:250:1::0;93312:146:0::1;93486:18:::0;;93471:12:::1;93515:448;93537:4;93532:2;:9;93515:448;;;93564:10;93577:11;93589:2;93577:15;;;;;;-1:-1:-1::0;;;93577:15:0::1;;;;;;;;;;;;;;;93564:28;;93607:14;93624:7;93632:2;93624:11;;;;;;-1:-1:-1::0;;;93624:11:0::1;;;;;;;;;;;;;;;93607:28;;93657:9;93652:300;93676:6;93672:1;:10;93652:300;;;93753:12;;93738;;:27;93708:139;;;;-1:-1:-1::0;;;93708:139:0::1;;;;;;;:::i;:::-;93868:16;93878:2;93882:1;93868:9;:16::i;:::-;93920:12;::::0;:16:::1;::::0;93935:1:::1;93920:16;:::i;:::-;93905:12;:31:::0;93684:3;::::1;::::0;::::1;:::i;:::-;;;;93652:300;;;;93515:448;;93543:4;;;;;:::i;:::-;;;;93515:448;;94703:90:::0;80383:24;13348:10;80508:130;:::i;80383:24::-;80361:119;;;;-1:-1:-1;;;80361:119:0;;;;;;;:::i;:::-;94769:9:::1;:16:::0;;-1:-1:-1;;94769:16:0::1;::::0;::::1;;::::0;;;::::1;::::0;;94703:90::o;93978:139::-;-1:-1:-1;;;;;94087:22:0;;94040:7;94087:22;;;:16;:22;;;;;;94067:17;;:42;;94087:22;94067:42;:::i;100205:2344::-;12073:21;:19;:21::i;:::-;100419:8:::1;:15;100399:9;:16;:35;100377:145;;;::::0;-1:-1:-1;;;100377:145:0;;23683:2:1;100377:145:0::1;::::0;::::1;23665:21:1::0;23722:2;23702:18;;;23695:30;23761:34;23741:18;;;23734:62;23832:30;23812:18;;;23805:58;23880:19;;100377:145:0::1;23655:250:1::0;100377:145:0::1;100576:6;:13;100557:8;:15;:32;100535:139;;;::::0;-1:-1:-1;;;100535:139:0;;20259:2:1;100535:139:0::1;::::0;::::1;20241:21:1::0;20298:2;20278:18;;;20271:30;20337:34;20317:18;;;20310:62;20408:27;20388:18;;;20381:55;20453:19;;100535:139:0::1;20231:247:1::0;100535:139:0::1;100695:14;::::0;;;::::1;;;100687:49;;;::::0;-1:-1:-1;;;100687:49:0;;18789:2:1;100687:49:0::1;::::0;::::1;18771:21:1::0;18828:2;18808:18;;;18801:30;-1:-1:-1;;;18847:18:1;;;18840:52;18909:18;;100687:49:0::1;18761:172:1::0;100687:49:0::1;100749:22;100791:9:::0;100786:116:::1;100810:8;:15;100806:1;:19;100786:116;;;100881:6;100888:1;100881:9;;;;;;-1:-1:-1::0;;;100881:9:0::1;;;;;;;;;;;;;;;100864:14;:26;;;;:::i;:::-;100847:43:::0;-1:-1:-1;100827:3:0;::::1;::::0;::::1;:::i;:::-;;;;100786:116;;;;100939:2;100922:14;:19;100914:53;;;::::0;-1:-1:-1;;;100914:53:0;;23333:2:1;100914:53:0::1;::::0;::::1;23315:21:1::0;23372:2;23352:18;;;23345:30;-1:-1:-1;;;23391:18:1;;;23384:51;23452:18;;100914:53:0::1;23305:171:1::0;100914:53:0::1;101033:14;101015:15;;:32;;;;:::i;:::-;101002:9;:45;100980:129;;;::::0;-1:-1:-1;;;100980:129:0;;21805:2:1;100980:129:0::1;::::0;::::1;21787:21:1::0;21844:2;21824:18;;;21817:30;21883:34;21863:18;;;21856:62;-1:-1:-1;;;21934:18:1;;;21927:32;21976:19;;100980:129:0::1;21777:224:1::0;100980:129:0::1;101127:9;101122:1420;101146:8;:15;101142:1;:19;101122:1420;;;101183:23;101209:9;101219:1;101209:12;;;;;;-1:-1:-1::0;;;101209:12:0::1;;;;;;;;;;;;;;;101183:38;;101236:15;101254:8;101263:1;101254:11;;;;;;-1:-1:-1::0;;;101254:11:0::1;;;;;;;;;;;;;;;101236:29;;101280:17;101300:6;101307:1;101300:9;;;;;;-1:-1:-1::0;;;101300:9:0::1;;;;;;;;;;;;;;;101280:29;;101397:10;-1:-1:-1::0;;;;;101352:55:0::1;101360:15;-1:-1:-1::0;;;;;101352:32:0::1;;101385:7;101352:41;;;;;;;;;;;;;17976:25:1::0;;17964:2;17949:18;;17931:76;101352:41:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;101352:55:0::1;;101326:137;;;::::0;-1:-1:-1;;;101326:137:0;;27196:2:1;101326:137:0::1;::::0;::::1;27178:21:1::0;27235:2;27215:18;;;27208:30;-1:-1:-1;;;27254:18:1;;;27247:50;27314:18;;101326:137:0::1;27168:170:1::0;101326:137:0::1;-1:-1:-1::0;;;;;101506:29:0;::::1;101538:1;101506:29:::0;;;:12:::1;:29;::::0;;;;;101480:127:::1;;;::::0;-1:-1:-1;;;101480:127:0;;21444:2:1;101480:127:0::1;::::0;::::1;21426:21:1::0;;;21463:18;;;21456:30;21522:34;21502:18;;;21495:62;21574:18;;101480:127:0::1;21416:182:1::0;101480:127:0::1;-1:-1:-1::0;;;;;101730:29:0;::::1;;::::0;;;:12:::1;:29;::::0;;;;;;;;101650:17:::1;:34:::0;;;;;:43;;;;;;;;;;:55:::1;::::0;101696:9;;101650:55:::1;:::i;:::-;:109;;101624:212;;;::::0;-1:-1:-1;;;101624:212:0;;24473:2:1;101624:212:0::1;::::0;::::1;24455:21:1::0;24512:2;24492:18;;;24485:30;24551:34;24531:18;;;24524:62;-1:-1:-1;;;24602:18:1;;;24595:39;24651:19;;101624:212:0::1;24445:231:1::0;101624:212:0::1;101907:12;;101894:9;101879:12;;:24;;;;:::i;:::-;:40;;101853:140;;;::::0;-1:-1:-1;;;101853:140:0;;25312:2:1;101853:140:0::1;::::0;::::1;25294:21:1::0;25351:2;25331:18;;;25324:30;25390:34;25370:18;;;25363:62;-1:-1:-1;;;25441:18:1;;;25434:36;25487:19;;101853:140:0::1;25284:228:1::0;101853:140:0::1;102067:15;;102054:9;102036:15;;:27;;;;:::i;:::-;:46;;102010:135;;;::::0;-1:-1:-1;;;102010:135:0;;21088:2:1;102010:135:0::1;::::0;::::1;21070:21:1::0;21127:2;21107:18;;;21100:30;21166:29;21146:18;;;21139:57;21213:18;;102010:135:0::1;21060:177:1::0;102010:135:0::1;102167:9;102162:99;102186:9;102182:1;:13;102162:99;;;102221:24;102231:10;102243:1;102221:9;:24::i;:::-;102197:3:::0;::::1;::::0;::::1;:::i;:::-;;;;102162:99;;;;102313:9;102295:15;;:27;;;;:::i;:::-;102277:15;:45:::0;102354:12:::1;::::0;:24:::1;::::0;102369:9;;102354:24:::1;:::i;:::-;102339:12;:39:::0;-1:-1:-1;;;;;102458:34:0;::::1;;::::0;;;:17:::1;:34;::::0;;;;;;;:43;;;;;;;;;:72:::1;::::0;102521:9;;102458:72:::1;:::i;:::-;-1:-1:-1::0;;;;;102395:34:0;;::::1;;::::0;;;:17:::1;:34;::::0;;;;;;;:43;;;;;;;;;;:135;;;;-1:-1:-1;101163:3:0;::::1;::::0;::::1;:::i;:::-;;;;101122:1420;;;;12105:1;12117:20:::0;11511:1;12637:7;:22;12454:213;30881:238;29861:13;:11;:13::i;:::-;-1:-1:-1;;;;;30984:22:0;::::1;30962:110;;;::::0;-1:-1:-1;;;30962:110:0;;19852:2:1;30962:110:0::1;::::0;::::1;19834:21:1::0;19891:2;19871:18;;;19864:30;19930:34;19910:18;;;19903:62;-1:-1:-1;;;19981:18:1;;;19974:36;20027:19;;30962:110:0::1;19824:228:1::0;30962:110:0::1;31083:28;31102:8;31083:18;:28::i;80891:124::-:0;80383:24;13348:10;80508:130;:::i;80383:24::-;80361:119;;;;-1:-1:-1;;;80361:119:0;;;;;;;:::i;:::-;80972:35:::1;-1:-1:-1::0;;;;;;;;;;;80999:7:0::1;80972:11;:35::i;65843:213::-:0;65900:4;65990:13;;65980:7;:23;65937:111;;;;-1:-1:-1;;66021:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;66021:27:0;;;;66020:28;;65843:213::o;75295:196::-;75410:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;75410:29:0;-1:-1:-1;;;;;75410:29:0;;;;;;;;;75455:28;;75410:24;;75455:28;;;;;;;75295:196;;;:::o;60602:1232::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;60745:7:0;60847:13;;60840:4;:20;60836:931;;;60885:31;60919:17;;;:11;:17;;;;;;;;;60885:51;;;;;;;;;-1:-1:-1;;;;;60885:51:0;;;;-1:-1:-1;;;60885:51:0;;-1:-1:-1;;;;;60885:51:0;;;;;;;;-1:-1:-1;;;60885:51:0;;;;;;;;;;;;;;60959:789;;61013:14;;-1:-1:-1;;;;;61013:28:0;;61009:109;;61081:9;60602:1232;-1:-1:-1;;;60602:1232:0:o;61009:109::-;-1:-1:-1;;;61484:6:0;61533:17;;;;:11;:17;;;;;;;;;61521:29;;;;;;;;;-1:-1:-1;;;;;61521:29:0;;;;;-1:-1:-1;;;61521:29:0;;-1:-1:-1;;;;;61521:29:0;;;;;;;;-1:-1:-1;;;61521:29:0;;;;;;;;;;;;;61585:28;61581:117;;61657:9;60602:1232;-1:-1:-1;;;60602:1232:0:o;61581:117::-;61440:285;;;60836:931;;61795:31;;-1:-1:-1;;;61795:31:0;;;;;;;;;;;12153:293;11555:1;12287:7;;:19;;12279:63;;;;-1:-1:-1;;;12279:63:0;;26836:2:1;12279:63:0;;;26818:21:1;26875:2;26855:18;;;26848:30;26914:33;26894:18;;;26887:61;26965:18;;12279:63:0;26808:181:1;12279:63:0;11555:1;12420:7;:18;12153:293::o;1179:190::-;1304:4;1357;1328:25;1341:5;1348:4;1328:12;:25::i;:::-;:33;;1179:190;-1:-1:-1;;;;1179:190:0:o;90218:437::-;90316:17;;-1:-1:-1;;;;;90293:20:0;;;;;;:16;:20;;;;;;:40;90271:117;;;;-1:-1:-1;;;90271:117:0;;19496:2:1;90271:117:0;;;19478:21:1;19535:2;19515:18;;;19508:30;19574:29;19554:18;;;19547:57;19621:18;;90271:117:0;19468:177:1;90271:117:0;90436:12;;90421;;:27;90399:115;;;;-1:-1:-1;;;90399:115:0;;;;;;;:::i;:::-;90527:16;90537:2;90541:1;90527:9;:16::i;:::-;-1:-1:-1;;;;;90579:20:0;;;;;;:16;:20;;;;;;:24;;90602:1;90579:24;:::i;:::-;-1:-1:-1;;;;;90556:20:0;;;;;;:16;:20;;;;;:47;90631:12;;:16;;90646:1;90631:16;:::i;:::-;90616:12;:31;-1:-1:-1;90218:437:0:o;70243:2130::-;70358:35;70396:21;70409:7;70396:12;:21::i;:::-;70358:59;;70456:4;-1:-1:-1;;;;;70434:26:0;:13;:18;;;-1:-1:-1;;;;;70434:26:0;;70430:67;;70469:28;;-1:-1:-1;;;70469:28:0;;;;;;;;;;;70430:67;70510:22;13348:10;-1:-1:-1;;;;;70536:20:0;;;;:73;;-1:-1:-1;70573:36:0;70590:4;13348:10;64418:214;:::i;70573:36::-;70536:126;;;-1:-1:-1;13348:10:0;70626:20;70638:7;70626:11;:20::i;:::-;-1:-1:-1;;;;;70626:36:0;;70536:126;70510:153;;70681:17;70676:66;;70707:35;;-1:-1:-1;;;70707:35:0;;;;;;;;;;;70676:66;-1:-1:-1;;;;;70757:16:0;;70753:52;;70782:23;;-1:-1:-1;;;70782:23:0;;;;;;;;;;;70753:52;70818:43;70840:4;70846:2;70850:7;70859:1;70818:21;:43::i;:::-;70926:35;70943:1;70947:7;70956:4;70926:8;:35::i;:::-;-1:-1:-1;;;;;71257:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;71257:31:0;;;-1:-1:-1;;;;;71257:31:0;;;-1:-1:-1;;71257:31:0;;;;;;;71303:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;71303:29:0;;;;;;;;;;;71383:20;;;:11;:20;;;;;;71418:18;;-1:-1:-1;;;;;;71451:49:0;;;;-1:-1:-1;;;71484:15:0;71451:49;;;;;;;;;;71774:11;;71834:24;;;;;71877:13;;71383:20;;71834:24;;71877:13;71873:384;;72087:13;;72072:11;:28;72068:174;;72125:20;;72194:28;;;;-1:-1:-1;;;;;72168:54:0;-1:-1:-1;;;72168:54:0;-1:-1:-1;;;;;;72168:54:0;;;-1:-1:-1;;;;;72125:20:0;;72168:54;;;;72068:174;70243:2130;;;72304:7;72300:2;-1:-1:-1;;;;;72285:27:0;72294:4;-1:-1:-1;;;;;72285:27:0;;;;;;;;;;;70243:2130;;;;;:::o;30140:132::-;30048:6;;-1:-1:-1;;;;;30048:6:0;13348:10;30204:23;30196:68;;;;-1:-1:-1;;;30196:68:0;;22611:2:1;30196:68:0;;;22593:21:1;;;22630:18;;;22623:30;22689:34;22669:18;;;22662:62;22741:18;;30196:68:0;22583:182:1;31279:191:0;31372:6;;;-1:-1:-1;;;;;31389:17:0;;;-1:-1:-1;;;;;;31389:17:0;;;;;;;31422:40;;31372:6;;;31389:17;31372:6;;31422:40;;31353:16;;31422:40;31279:191;;:::o;79477:229::-;79552:22;79560:4;79566:7;79552;:22::i;:::-;79547:152;;79591:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;79591:29:0;;;;;;;;;:36;;-1:-1:-1;;79591:36:0;79623:4;79591:36;;;79674:12;13348:10;;13268:98;79674:12;-1:-1:-1;;;;;79647:40:0;79665:7;-1:-1:-1;;;;;79647:40:0;79659:4;79647:40;;;;;;;;;;79477:229;;:::o;75983:772::-;76180:155;;-1:-1:-1;;;76180:155:0;;76146:4;;-1:-1:-1;;;;;76180:36:0;;;;;:155;;13348:10;;76266:4;;76289:7;;76315:5;;76180:155;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76180:155:0;;;;;;;;-1:-1:-1;;76180:155:0;;;;;;;;;;;;:::i;:::-;;;76163:585;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76506:13:0;;76502:235;;76552:40;;-1:-1:-1;;;76552:40:0;;;;;;;;;;;76502:235;76695:6;76689:13;76680:6;76676:2;76672:15;76665:38;76163:585;-1:-1:-1;;;;;;76391:55:0;-1:-1:-1;;;76391:55:0;;-1:-1:-1;76163:585:0;75983:772;;;;;;:::o;98543:532::-;98599:13;98629:10;98625:53;;-1:-1:-1;;98656:10:0;;;;;;;;;;;;-1:-1:-1;;;98656:10:0;;;;;98543:532::o;98625:53::-;98703:5;98688:12;98744:78;98751:9;;98744:78;;98777:8;;;;:::i;:::-;;-1:-1:-1;98800:10:0;;-1:-1:-1;98808:2:0;98800:10;;:::i;:::-;;;98744:78;;;98832:19;98864:6;-1:-1:-1;;;;;98854:17:0;;;;;-1:-1:-1;;;98854:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;98854:17:0;;98832:39;;98882:154;98889:10;;98882:154;;98916:11;98926:1;98916:11;;:::i;:::-;;-1:-1:-1;98985:10:0;98993:2;98985:5;:10;:::i;:::-;98972:24;;:2;:24;:::i;:::-;98959:39;;98942:6;98949;98942:14;;;;;;-1:-1:-1;;;98942:14:0;;;;;;;;;;;;:56;-1:-1:-1;;;;;98942:56:0;;;;;;;;-1:-1:-1;99013:11:0;99022:2;99013:11;;:::i;:::-;;;98882:154;;66140:104;66209:27;66219:2;66223:8;66209:27;;;;;;;;;;;;:9;:27::i;79834:230::-;79909:22;79917:4;79923:7;79909;:22::i;:::-;79905:152;;;79980:5;79948:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;79948:29:0;;;;;;;;;;:37;;-1:-1:-1;;79948:37:0;;;80005:40;13348:10;;79948:12;;80005:40;;79980:5;80005:40;79834:230;;:::o;2046:328::-;2156:7;2204:4;2156:7;2219:118;2243:5;:12;2239:1;:16;2219:118;;;2292:33;2302:12;2316:5;2322:1;2316:8;;;;;;-1:-1:-1;;;2316:8:0;;;;;;;;;;;;;;;2292:9;:33::i;:::-;2277:48;-1:-1:-1;2257:3:0;;;;:::i;:::-;;;;2219:118;;;-1:-1:-1;2354:12:0;2046:328;-1:-1:-1;;;2046:328:0:o;97040:507::-;97224:12;97206:15;97266:18;97276:8;97224:12;97266:18;:::i;:::-;97252:32;;97247:293;97296:3;97286:7;:13;97247:293;;;97353:21;;;;:12;:21;;;;;;:26;;:69;;;97404:13;;97421:1;97404:18;97353:69;:107;;;-1:-1:-1;97447:13:0;;;;97353:107;97327:201;;;;-1:-1:-1;;;97327:201:0;;24112:2:1;97327:201:0;;;24094:21:1;;;24131:18;;;24124:30;24190:34;24170:18;;;24163:62;24242:18;;97327:201:0;24084:182:1;97327:201:0;97301:9;;;:::i;:::-;;;97247:293;;;;97040:507;;;;;:::o;66617:1940::-;66740:20;66763:13;-1:-1:-1;;;;;66791:16:0;;66787:48;;66816:19;;-1:-1:-1;;;66816:19:0;;;;;;;;;;;66787:48;66850:13;66846:44;;66872:18;;-1:-1:-1;;;66872:18:0;;;;;;;;;;;66846:44;66903:61;66933:1;66937:2;66941:12;66955:8;66903:21;:61::i;:::-;-1:-1:-1;;;;;67241:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;67300:49:0;;-1:-1:-1;;;;;67241:44:0;;;;;;;67300:49;;;;-1:-1:-1;;67241:44:0;;;;;;67300:49;;;;;;;;;;;;;;;;67366:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;67416:66:0;;;-1:-1:-1;;;67466:15:0;67416:66;;;;;;;;;;;;;67366:25;;67563:23;;;;32920:19;:23;67603:822;;67643:504;67674:38;;67699:12;;-1:-1:-1;;;;;67674:38:0;;;67691:1;;67674:38;;67691:1;;67674:38;67766:212;67835:1;67868:2;67901:14;;;;;;67946:5;67766:30;:212::i;:::-;67735:365;;68036:40;;-1:-1:-1;;;68036:40:0;;;;;;;;;;;67735:365;68142:3;68127:12;:18;67643:504;;68228:12;68211:13;;:29;68207:43;;68242:8;;;68207:43;67603:822;;;68291:119;68322:40;;68347:14;;;;;-1:-1:-1;;;;;68322:40:0;;;68339:1;;68322:40;;68339:1;;68322:40;68405:3;68390:12;:18;68291:119;;67603:822;-1:-1:-1;68439:13:0;:28;;;68489:60;;68522:2;68526:12;68540:8;68489:60;:::i;9360:149::-;9423:7;9454:1;9450;:5;:51;;9612:13;9711:15;;;9747:4;9740:15;;;9794:4;9778:21;;9450:51;;;9612:13;9711:15;;;9747:4;9740:15;;;9794:4;9778:21;;9458:20;9696:114;-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:768::-;479:5;532:3;525:4;517:6;513:17;509:27;499:2;;554:5;547;540:20;499:2;594:6;581:20;620:4;644:60;660:43;700:2;660:43;:::i;:::-;644:60;:::i;:::-;726:3;750:2;745:3;738:15;778:2;773:3;769:12;762:19;;813:2;805:6;801:15;865:3;860:2;854;851:1;847:10;839:6;835:23;831:32;828:41;825:2;;;886:5;879;872:20;825:2;912:5;926:238;940:2;937:1;934:9;926:238;;;1011:3;998:17;1028:31;1053:5;1028:31;:::i;:::-;1072:18;;1110:12;;;;1142;;;;958:1;951:9;926:238;;;-1:-1:-1;1182:5:1;;489:704;-1:-1:-1;;;;;;;489:704:1:o;1198:395::-;1261:8;1271:6;1325:3;1318:4;1310:6;1306:17;1302:27;1292:2;;1350:8;1340;1333:26;1292:2;-1:-1:-1;1380:20:1;;-1:-1:-1;;;;;1412:30:1;;1409:2;;;1462:8;1452;1445:26;1409:2;1506:4;1498:6;1494:17;1482:29;;1566:3;1559:4;1549:6;1546:1;1542:14;1534:6;1530:27;1526:38;1523:47;1520:2;;;1583:1;1580;1573:12;1520:2;1282:311;;;;;:::o;1598:693::-;1652:5;1705:3;1698:4;1690:6;1686:17;1682:27;1672:2;;1727:5;1720;1713:20;1672:2;1767:6;1754:20;1793:4;1817:60;1833:43;1873:2;1833:43;:::i;1817:60::-;1899:3;1923:2;1918:3;1911:15;1951:2;1946:3;1942:12;1935:19;;1986:2;1978:6;1974:15;2038:3;2033:2;2027;2024:1;2020:10;2012:6;2008:23;2004:32;2001:41;1998:2;;;2059:5;2052;2045:20;1998:2;2085:5;2099:163;2113:2;2110:1;2107:9;2099:163;;;2170:17;;2158:30;;2208:12;;;;2240;;;;2131:1;2124:9;2099:163;;2296:257;2355:6;2408:2;2396:9;2387:7;2383:23;2379:32;2376:2;;;2429:6;2421;2414:22;2376:2;2473:9;2460:23;2492:31;2517:5;2492:31;:::i;2558:261::-;2628:6;2681:2;2669:9;2660:7;2656:23;2652:32;2649:2;;;2702:6;2694;2687:22;2649:2;2739:9;2733:16;2758:31;2783:5;2758:31;:::i;2824:398::-;2892:6;2900;2953:2;2941:9;2932:7;2928:23;2924:32;2921:2;;;2974:6;2966;2959:22;2921:2;3018:9;3005:23;3037:31;3062:5;3037:31;:::i;:::-;3087:5;-1:-1:-1;3144:2:1;3129:18;;3116:32;3157:33;3116:32;3157:33;:::i;:::-;3209:7;3199:17;;;2911:311;;;;;:::o;3227:466::-;3304:6;3312;3320;3373:2;3361:9;3352:7;3348:23;3344:32;3341:2;;;3394:6;3386;3379:22;3341:2;3438:9;3425:23;3457:31;3482:5;3457:31;:::i;:::-;3507:5;-1:-1:-1;3564:2:1;3549:18;;3536:32;3577:33;3536:32;3577:33;:::i;:::-;3331:362;;3629:7;;-1:-1:-1;;;3683:2:1;3668:18;;;;3655:32;;3331:362::o;3698:824::-;3793:6;3801;3809;3817;3870:3;3858:9;3849:7;3845:23;3841:33;3838:2;;;3892:6;3884;3877:22;3838:2;3936:9;3923:23;3955:31;3980:5;3955:31;:::i;:::-;4005:5;-1:-1:-1;4062:2:1;4047:18;;4034:32;4075:33;4034:32;4075:33;:::i;:::-;4127:7;-1:-1:-1;4181:2:1;4166:18;;4153:32;;-1:-1:-1;4236:2:1;4221:18;;4208:32;-1:-1:-1;;;;;4252:30:1;;4249:2;;;4300:6;4292;4285:22;4249:2;4328:22;;4381:4;4373:13;;4369:27;-1:-1:-1;4359:2:1;;4415:6;4407;4400:22;4359:2;4443:73;4508:7;4503:2;4490:16;4485:2;4481;4477:11;4443:73;:::i;:::-;4433:83;;;3828:694;;;;;;;:::o;4527:392::-;4592:6;4600;4653:2;4641:9;4632:7;4628:23;4624:32;4621:2;;;4674:6;4666;4659:22;4621:2;4718:9;4705:23;4737:31;4762:5;4737:31;:::i;:::-;4787:5;-1:-1:-1;4844:2:1;4829:18;;4816:32;4857:30;4816:32;4857:30;:::i;4924:325::-;4992:6;5000;5053:2;5041:9;5032:7;5028:23;5024:32;5021:2;;;5074:6;5066;5059:22;5021:2;5118:9;5105:23;5137:31;5162:5;5137:31;:::i;:::-;5187:5;5239:2;5224:18;;;;5211:32;;-1:-1:-1;;;5011:238:1:o;5254:503::-;5347:6;5355;5408:2;5396:9;5387:7;5383:23;5379:32;5376:2;;;5429:6;5421;5414:22;5376:2;5474:9;5461:23;-1:-1:-1;;;;;5499:6:1;5496:30;5493:2;;;5544:6;5536;5529:22;5493:2;5572:61;5625:7;5616:6;5605:9;5601:22;5572:61;:::i;:::-;5562:71;;;5683:2;5672:9;5668:18;5655:32;5696:31;5721:5;5696:31;:::i;5762:625::-;5880:6;5888;5941:2;5929:9;5920:7;5916:23;5912:32;5909:2;;;5962:6;5954;5947:22;5909:2;6007:9;5994:23;-1:-1:-1;;;;;6077:2:1;6069:6;6066:14;6063:2;;;6098:6;6090;6083:22;6063:2;6126:61;6179:7;6170:6;6159:9;6155:22;6126:61;:::i;:::-;6116:71;;6240:2;6229:9;6225:18;6212:32;6196:48;;6269:2;6259:8;6256:16;6253:2;;;6290:6;6282;6275:22;6253:2;;6318:63;6373:7;6362:8;6351:9;6347:24;6318:63;:::i;:::-;6308:73;;;5899:488;;;;;:::o;6392:861::-;6544:6;6552;6560;6613:2;6601:9;6592:7;6588:23;6584:32;6581:2;;;6634:6;6626;6619:22;6581:2;6679:9;6666:23;-1:-1:-1;;;;;6749:2:1;6741:6;6738:14;6735:2;;;6770:6;6762;6755:22;6735:2;6798:61;6851:7;6842:6;6831:9;6827:22;6798:61;:::i;:::-;6788:71;;6912:2;6901:9;6897:18;6884:32;6868:48;;6941:2;6931:8;6928:16;6925:2;;;6962:6;6954;6947:22;6925:2;6990:63;7045:7;7034:8;7023:9;7019:24;6990:63;:::i;:::-;6980:73;;7106:2;7095:9;7091:18;7078:32;7062:48;;7135:2;7125:8;7122:16;7119:2;;;7156:6;7148;7141:22;7119:2;;7184:63;7239:7;7228:8;7217:9;7213:24;7184:63;:::i;:::-;7174:73;;;6571:682;;;;;:::o;7258:803::-;7380:6;7388;7396;7404;7457:2;7445:9;7436:7;7432:23;7428:32;7425:2;;;7478:6;7470;7463:22;7425:2;7523:9;7510:23;-1:-1:-1;;;;;7593:2:1;7585:6;7582:14;7579:2;;;7614:6;7606;7599:22;7579:2;7658:70;7720:7;7711:6;7700:9;7696:22;7658:70;:::i;:::-;7747:8;;-1:-1:-1;7632:96:1;-1:-1:-1;7835:2:1;7820:18;;7807:32;;-1:-1:-1;7851:16:1;;;7848:2;;;7885:6;7877;7870:22;7848:2;;7929:72;7993:7;7982:8;7971:9;7967:24;7929:72;:::i;:::-;7415:646;;;;-1:-1:-1;8020:8:1;-1:-1:-1;;;;7415:646:1:o;8066:525::-;8161:6;8169;8177;8230:2;8218:9;8209:7;8205:23;8201:32;8198:2;;;8251:6;8243;8236:22;8198:2;8296:9;8283:23;-1:-1:-1;;;;;8321:6:1;8318:30;8315:2;;;8366:6;8358;8351:22;8315:2;8410:70;8472:7;8463:6;8452:9;8448:22;8410:70;:::i;:::-;8499:8;;8384:96;;-1:-1:-1;8581:2:1;8566:18;;;;8553:32;;8188:403;-1:-1:-1;;;;8188:403:1:o;8596:457::-;8682:6;8690;8743:2;8731:9;8722:7;8718:23;8714:32;8711:2;;;8764:6;8756;8749:22;8711:2;8809:9;8796:23;-1:-1:-1;;;;;8834:6:1;8831:30;8828:2;;;8879:6;8871;8864:22;8828:2;8923:70;8985:7;8976:6;8965:9;8961:22;8923:70;:::i;:::-;9012:8;;8897:96;;-1:-1:-1;8701:352:1;-1:-1:-1;;;;8701:352:1:o;9058:251::-;9114:6;9167:2;9155:9;9146:7;9142:23;9138:32;9135:2;;;9188:6;9180;9173:22;9135:2;9232:9;9219:23;9251:28;9273:5;9251:28;:::i;9314:255::-;9381:6;9434:2;9422:9;9413:7;9409:23;9405:32;9402:2;;;9455:6;9447;9440:22;9402:2;9492:9;9486:16;9511:28;9533:5;9511:28;:::i;9574:793::-;9654:6;9662;9670;9678;9686;9739:3;9727:9;9718:7;9714:23;9710:33;9707:2;;;9761:6;9753;9746:22;9707:2;9805:9;9792:23;9824:28;9846:5;9824:28;:::i;:::-;9871:5;-1:-1:-1;9928:2:1;9913:18;;9900:32;9941:30;9900:32;9941:30;:::i;:::-;9990:7;-1:-1:-1;10049:2:1;10034:18;;10021:32;10062:30;10021:32;10062:30;:::i;:::-;10111:7;-1:-1:-1;10170:2:1;10155:18;;10142:32;10183:30;10142:32;10183:30;:::i;:::-;10232:7;-1:-1:-1;10291:3:1;10276:19;;10263:33;10305:30;10263:33;10305:30;:::i;:::-;10354:7;10344:17;;;9697:670;;;;;;;;:::o;10372:325::-;10440:6;10448;10501:2;10489:9;10480:7;10476:23;10472:32;10469:2;;;10522:6;10514;10507:22;10469:2;10563:9;10550:23;10540:33;;10623:2;10612:9;10608:18;10595:32;10636:31;10661:5;10636:31;:::i;10702:258::-;10770:6;10778;10831:2;10819:9;10810:7;10806:23;10802:32;10799:2;;;10852:6;10844;10837:22;10799:2;-1:-1:-1;;10880:23:1;;;10950:2;10935:18;;;10922:32;;-1:-1:-1;10789:171:1:o;10965:255::-;11023:6;11076:2;11064:9;11055:7;11051:23;11047:32;11044:2;;;11097:6;11089;11082:22;11044:2;11141:9;11128:23;11160:30;11184:5;11160:30;:::i;11225:259::-;11294:6;11347:2;11335:9;11326:7;11322:23;11318:32;11315:2;;;11368:6;11360;11353:22;11315:2;11405:9;11399:16;11424:30;11448:5;11424:30;:::i;11489:480::-;11558:6;11611:2;11599:9;11590:7;11586:23;11582:32;11579:2;;;11632:6;11624;11617:22;11579:2;11677:9;11664:23;-1:-1:-1;;;;;11702:6:1;11699:30;11696:2;;;11747:6;11739;11732:22;11696:2;11775:22;;11828:4;11820:13;;11816:27;-1:-1:-1;11806:2:1;;11862:6;11854;11847:22;11806:2;11890:73;11955:7;11950:2;11937:16;11932:2;11928;11924:11;11890:73;:::i;11974:190::-;12033:6;12086:2;12074:9;12065:7;12061:23;12057:32;12054:2;;;12107:6;12099;12092:22;12054:2;-1:-1:-1;12135:23:1;;12044:120;-1:-1:-1;12044:120:1:o;12169:194::-;12239:6;12292:2;12280:9;12271:7;12267:23;12263:32;12260:2;;;12313:6;12305;12298:22;12260:2;-1:-1:-1;12341:16:1;;12250:113;-1:-1:-1;12250:113:1:o;12368:326::-;12445:6;12453;12461;12514:2;12502:9;12493:7;12489:23;12485:32;12482:2;;;12535:6;12527;12520:22;12482:2;-1:-1:-1;;12563:23:1;;;12633:2;12618:18;;12605:32;;-1:-1:-1;12684:2:1;12669:18;;;12656:32;;12472:222;-1:-1:-1;12472:222:1:o;12699:464::-;12794:6;12802;12810;12818;12826;12879:3;12867:9;12858:7;12854:23;12850:33;12847:2;;;12901:6;12893;12886:22;12847:2;-1:-1:-1;;12929:23:1;;;12999:2;12984:18;;12971:32;;-1:-1:-1;13050:2:1;13035:18;;13022:32;;13101:2;13086:18;;13073:32;;-1:-1:-1;13152:3:1;13137:19;13124:33;;-1:-1:-1;12837:326:1;-1:-1:-1;12837:326:1:o;13168:257::-;13209:3;13247:5;13241:12;13274:6;13269:3;13262:19;13290:63;13346:6;13339:4;13334:3;13330:14;13323:4;13316:5;13312:16;13290:63;:::i;:::-;13407:2;13386:15;-1:-1:-1;;13382:29:1;13373:39;;;;13414:4;13369:50;;13217:208;-1:-1:-1;;13217:208:1:o;13430:185::-;13472:3;13510:5;13504:12;13525:52;13570:6;13565:3;13558:4;13551:5;13547:16;13525:52;:::i;:::-;13593:16;;;;;13480:135;-1:-1:-1;;13480:135:1:o;13857:229::-;14006:2;14002:15;;;;-1:-1:-1;;13998:53:1;13986:66;;14077:2;14068:12;;13976:110::o;14091:1437::-;14469:3;14498;14533:6;14527:13;14563:3;14585:1;14613:9;14609:2;14605:18;14595:28;;14673:2;14662:9;14658:18;14695;14685:2;;14739:4;14731:6;14727:17;14717:27;;14685:2;14765;14813;14805:6;14802:14;14782:18;14779:38;14776:2;;;-1:-1:-1;;;14840:33:1;;14896:4;14893:1;14886:15;14926:4;14847:3;14914:17;14776:2;14957:18;14984:104;;;;15102:1;15097:322;;;;14950:469;;14984:104;-1:-1:-1;;15017:24:1;;15005:37;;15062:16;;;;-1:-1:-1;14984:104:1;;15097:322;29635:4;29654:17;;;29704:4;29688:21;;15192:3;15208:165;15222:6;15219:1;15216:13;15208:165;;;15300:14;;15287:11;;;15280:35;15343:16;;;;15237:10;;15208:165;;;15212:3;;15402:6;15397:3;15393:16;15386:23;;14950:469;;;;;;;15435:87;15460:61;15486:34;15516:3;-1:-1:-1;;;13803:16:1;;13844:1;13835:11;;13793:59;15486:34;15478:6;15460:61;:::i;:::-;-1:-1:-1;;;13680:20:1;;13725:1;13716:11;;13670:63;15435:87;15428:94;14477:1051;-1:-1:-1;;;;;14477:1051:1:o;15741:488::-;-1:-1:-1;;;;;16010:15:1;;;15992:34;;16062:15;;16057:2;16042:18;;16035:43;16109:2;16094:18;;16087:34;;;16157:3;16152:2;16137:18;;16130:31;;;15935:4;;16178:45;;16203:19;;16195:6;16178:45;:::i;:::-;16170:53;15944:285;-1:-1:-1;;;;;;15944:285:1:o;18012:219::-;18161:2;18150:9;18143:21;18124:4;18181:44;18221:2;18210:9;18206:18;18198:6;18181:44;:::i;18236:346::-;18438:2;18420:21;;;18477:2;18457:18;;;18450:30;-1:-1:-1;;;18511:2:1;18496:18;;18489:52;18573:2;18558:18;;18410:172::o;18938:351::-;19140:2;19122:21;;;19179:2;19159:18;;;19152:30;19218:29;19213:2;19198:18;;19191:57;19280:2;19265:18;;19112:177::o;20483:398::-;20685:2;20667:21;;;20724:2;20704:18;;;20697:30;20763:34;20758:2;20743:18;;20736:62;-1:-1:-1;;;20829:2:1;20814:18;;20807:32;20871:3;20856:19;;20657:224::o;22006:398::-;22208:2;22190:21;;;22247:2;22227:18;;;22220:30;22286:34;22281:2;22266:18;;22259:62;-1:-1:-1;;;22352:2:1;22337:18;;22330:32;22394:3;22379:19;;22180:224::o;25517:345::-;25719:2;25701:21;;;25758:2;25738:18;;;25731:30;-1:-1:-1;;;25792:2:1;25777:18;;25770:51;25853:2;25838:18;;25691:171::o;26220:409::-;26422:2;26404:21;;;26461:2;26441:18;;;26434:30;26500:34;26495:2;26480:18;;26473:62;-1:-1:-1;;;26566:2:1;26551:18;;26544:43;26619:3;26604:19;;26394:235::o;27343:402::-;27545:2;27527:21;;;27584:2;27564:18;;;27557:30;27623:34;27618:2;27603:18;;27596:62;-1:-1:-1;;;27689:2:1;27674:18;;27667:36;27735:3;27720:19;;27517:228::o;29120:275::-;29191:2;29185:9;29256:2;29237:13;;-1:-1:-1;;29233:27:1;29221:40;;-1:-1:-1;;;;;29276:34:1;;29312:22;;;29273:62;29270:2;;;29338:18;;:::i;:::-;29374:2;29367:22;29165:230;;-1:-1:-1;29165:230:1:o;29400:183::-;29460:4;-1:-1:-1;;;;;29485:6:1;29482:30;29479:2;;;29515:18;;:::i;:::-;-1:-1:-1;29560:1:1;29556:14;29572:4;29552:25;;29469:114::o;29720:128::-;29760:3;29791:1;29787:6;29784:1;29781:13;29778:2;;;29797:18;;:::i;:::-;-1:-1:-1;29833:9:1;;29768:80::o;29853:120::-;29893:1;29919;29909:2;;29924:18;;:::i;:::-;-1:-1:-1;29958:9:1;;29899:74::o;29978:168::-;30018:7;30084:1;30080;30076:6;30072:14;30069:1;30066:21;30061:1;30054:9;30047:17;30043:45;30040:2;;;30091:18;;:::i;:::-;-1:-1:-1;30131:9:1;;30030:116::o;30151:125::-;30191:4;30219:1;30216;30213:8;30210:2;;;30224:18;;:::i;:::-;-1:-1:-1;30261:9:1;;30200:76::o;30281:258::-;30353:1;30363:113;30377:6;30374:1;30371:13;30363:113;;;30453:11;;;30447:18;30434:11;;;30427:39;30399:2;30392:10;30363:113;;;30494:6;30491:1;30488:13;30485:2;;;-1:-1:-1;;30529:1:1;30511:16;;30504:27;30334:205::o;30544:380::-;30623:1;30619:12;;;;30666;;;30687:2;;30741:4;30733:6;30729:17;30719:27;;30687:2;30794;30786:6;30783:14;30763:18;30760:38;30757:2;;;30840:10;30835:3;30831:20;30828:1;30821:31;30875:4;30872:1;30865:15;30903:4;30900:1;30893:15;30757:2;;30599:325;;;:::o;30929:135::-;30968:3;-1:-1:-1;;30989:17:1;;30986:2;;;31009:18;;:::i;:::-;-1:-1:-1;31056:1:1;31045:13;;30976:88::o;31069:175::-;31106:3;31150:4;31143:5;31139:16;31179:4;31170:7;31167:17;31164:2;;;31187:18;;:::i;:::-;31236:1;31223:15;;31114:130;-1:-1:-1;;31114:130:1:o;31249:112::-;31281:1;31307;31297:2;;31312:18;;:::i;:::-;-1:-1:-1;31346:9:1;;31287:74::o;31366:127::-;31427:10;31422:3;31418:20;31415:1;31408:31;31458:4;31455:1;31448:15;31482:4;31479:1;31472:15;31498:127;31559:10;31554:3;31550:20;31547:1;31540:31;31590:4;31587:1;31580:15;31614:4;31611:1;31604:15;31630:127;31691:10;31686:3;31682:20;31679:1;31672:31;31722:4;31719:1;31712:15;31746:4;31743:1;31736:15;31762:131;-1:-1:-1;;;;;31837:31:1;;31827:42;;31817:2;;31883:1;31880;31873:12;31898:118;31984:5;31977:13;31970:21;31963:5;31960:32;31950:2;;32006:1;32003;31996:12;32021:131;-1:-1:-1;;;;;;32095:32:1;;32085:43;;32075:2;;32142:1;32139;32132:12

Swarm Source

ipfs://dcd4ec928e22efde944324b41f5a6fe9f7cd87de0c225fa4551af9759505661d

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services