Token

NUOSBT (NUOSBT)

ERC-721

Overview

Max Total Supply

45 NUOSBT

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x12560a3ebbccf1759a81d93bfeb8c855d1800785

Filtered by Token Holder

0x65bfD15f62282096341737deAEb9647dd2732603

Balance

1 NUOSBT

0x65bfd15f62282096341737deaeb9647dd2732603

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

NUOSBT

Compiler Version

v0.8.13+commit.abaa5c0e

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-06-25
*/

pragma solidity 0.8.13;

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.2) (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 rebuilds 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 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(
            leavesLen + proofLen - 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 from 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) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                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 rebuilds 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 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(
            leavesLen + proofLen - 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 from 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) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                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.9.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;
    }

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

// 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.9.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) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 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 256, 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 << 3) < value ? 1 : 0);
        }
    }
}

// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)
/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// OpenZeppelin Contracts (last updated v4.9.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 `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return
            string(
                abi.encodePacked(
                    value < 0 ? "-" : "",
                    toString(SignedMath.abs(value))
                )
            );
    }

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

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(
        string memory a,
        string memory b
    ) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// OpenZeppelin Contracts (last updated v4.9.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. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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.9.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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [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://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/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.9.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.9.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 virtual override {
        _beforeApprove(to);

        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 {
        _beforeApprove(operator);

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

    function _beforeApprove(address to) internal virtual {}

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

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

        // 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 NUOSBT is ERC721A, OperatorAccessControl, ReentrancyGuard {
    bytes32 public _kycMintMerkleRoot;
    bytes32 public _preMintMerkleRoot;

    mapping(address => uint256) private addressMintCount;

    uint256 private _kycMintLimit = 0;

    uint256 private _preMintLimit = 0;

    uint256 private _publicMintLimit = 0;

    uint256 private _superMintLimit = 0;

    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 = 10000;

    uint256 _totalTokens;

    bool private _transferOpen = false;

    bool private _open = false;

    function setOpen(bool open) public onlyOperator {
        _open = open;
    }

    string private _nftName = "NUOSBT";
    string private _baseUri = "https://nft-game.s3.ap-east-1.amazonaws.com/nuo";

    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 burn(uint256 tokenId) public onlyOperator {
        super._burn(tokenId);
    }

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

    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal view override {
        require(_open, "error:10000 can't transfer");
    }

    function _beforeApprove(address to) internal view override {
        require(_open, "error:10000 can't approve");
    }

    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":"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"},{"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":"burn","outputs":[],"stateMutability":"nonpayable","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":"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":[],"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":"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":"setOpen","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":"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":"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

87976:14276:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61754:321;;;;;;;;;;-1:-1:-1;61754:321:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;61754:321:0;;;;;;;;97617:86;;;;;;;;;;-1:-1:-1;97683:12:0;;97617:86;;;738:25:1;;;726:2;711:18;97617:86:0;592:177:1;64990:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;66618:220::-;;;;;;;;;;-1:-1:-1;66618:220:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1896:32:1;;;1878:51;;1866:2;1851:18;66618:220:0;1732:203:1;66119:433:0;;;;;;;;;;-1:-1:-1;66119:433:0;;;;;:::i;:::-;;:::i;:::-;;99558:339;;;;;;;;;;-1:-1:-1;99558:339:0;;;;;:::i;:::-;;:::i;97810:446::-;;;;;;;;;;-1:-1:-1;97810:446:0;;;;;:::i;:::-;;:::i;93390:922::-;;;;;;:::i;:::-;;:::i;88050:33::-;;;;;;;;;;;;;;;;60994:312;;;;;;;;;;-1:-1:-1;61257:12:0;;61047:7;61241:13;:28;60994:312;;90526:434;;;;;;;;;;-1:-1:-1;90526:434:0;;;;;:::i;:::-;;:::i;67649:170::-;;;;;;;;;;-1:-1:-1;67649:170:0;;;;;:::i;:::-;;:::i;88090:33::-;;;;;;;;;;;;;;;;95250:633;;;;;;:::i;:::-;;:::i;91469:276::-;;;;;;;;;;-1:-1:-1;91469:276:0;;;;;:::i;:::-;;:::i;67890:185::-;;;;;;;;;;-1:-1:-1;67890:185:0;;;;;:::i;:::-;;:::i;96691:90::-;;;;;;;;;;-1:-1:-1;96691:90:0;;;;;:::i;:::-;;:::i;99225:166::-;;;;;;;;;;-1:-1:-1;99225:166:0;;;;;:::i;:::-;;:::i;90968:493::-;;;;;;;;;;-1:-1:-1;91266:13:0;;91305;;91347:16;;91393:17;;91438:15;;90968:493;;;6790:25:1;;;6846:2;6831:18;;6824:34;;;;6874:18;;;6867:34;;;;6932:2;6917:18;;6910:34;6975:3;6960:19;;6953:35;6777:3;6762:19;90968:493:0;6531:463:1;92088:391:0;;;;;;;;;;-1:-1:-1;92088:391:0;;;;;:::i;:::-;;:::i;64798:125::-;;;;;;;;;;-1:-1:-1;64798:125:0;;;;;:::i;:::-;;:::i;83234:130::-;;;;;;;;;;-1:-1:-1;83234:130:0;;;;;:::i;:::-;;:::i;99399:151::-;;;;;;;;;;-1:-1:-1;99399:151:0;;;;;:::i;:::-;-1:-1:-1;;;;;99513:29:0;99486:7;99513:29;;;:12;:29;;;;;;;99399:151;89015:79;;;;;;;;;;-1:-1:-1;89015:79:0;;;;;:::i;:::-;;:::i;62139:206::-;;;;;;;;;;-1:-1:-1;62139:206:0;;;;;:::i;:::-;;:::i;33421:103::-;;;;;;;;;;;;;:::i;89747:228::-;;;;;;;;;;-1:-1:-1;89747:228:0;;;;;:::i;:::-;;:::i;89983:535::-;;;;;;;;;;-1:-1:-1;89983:535:0;;;;;:::i;:::-;;:::i;:::-;;;;9626:14:1;;9619:22;9601:41;;9685:14;;9678:22;9673:2;9658:18;;9651:50;9574:18;89983:535:0;9439:268:1;32780:87:0;;;;;;;;;;-1:-1:-1;32853:6:0;;-1:-1:-1;;;;;32853:6:0;32780:87;;89332:407;;;;;;;;;;-1:-1:-1;89591:13:0;;89630;;89672:16;;89716:15;;89332:407;;;9943:25:1;;;9999:2;9984:18;;9977:34;;;;10027:18;;;10020:34;10085:2;10070:18;;10063:34;9930:3;9915:19;89332:407:0;9712:391:1;82031:164:0;;;;;;;;;;-1:-1:-1;82031:164:0;;;;;:::i;:::-;;:::i;65159:104::-;;;;;;;;;;;;;:::i;83489:120::-;;;;;;;;;;-1:-1:-1;83489:120:0;;;;;:::i;:::-;;:::i;97299:100::-;;;;;;;;;;-1:-1:-1;97299:100:0;;;;;:::i;:::-;;:::i;66910:349::-;;;;;;;;;;-1:-1:-1;66910:349:0;;;;;:::i;:::-;;:::i;97711:91::-;;;;;;;;;;-1:-1:-1;97782:12:0;;97711:91;;91753:327;;;;;;;;;;-1:-1:-1;91975:13:0;;92014;;92056:16;;91753:327;;;11885:25:1;;;11941:2;11926:18;;11919:34;;;;11969:18;;;11962:34;11873:2;11858:18;91753:327:0;11683:319:1;92487:450:0;;;;;;;;;;-1:-1:-1;92757:12:0;;92875:13;;92487:450;;;92757:12;;;;12261:14:1;12254:22;12236:41;;92757:12:0;92794;;;;12320:14:1;12313:22;12308:2;12293:18;;12286:50;92834:15:0;;;;;12379:14:1;12372:22;12352:18;;;12345:50;;;;92875:13:0;;;12438:14:1;12431:22;12426:2;12411:18;;12404:50;92915:14:0;;;;;;;12498::1;12491:22;12485:3;12470:19;;12463:51;12223:3;12208:19;92487:450:0;12007:513:1;98930:122:0;;;;;;;;;;-1:-1:-1;98930:122:0;;;;;:::i;:::-;;:::i;68146:392::-;;;;;;;;;;-1:-1:-1;68146:392:0;;;;;:::i;:::-;;:::i;94320:922::-;;;;;;:::i;:::-;;:::i;97407:202::-;;;;;;;;;;-1:-1:-1;97407:202:0;;;;;:::i;:::-;;:::i;95891:792::-;;;;;;;;;;-1:-1:-1;95891:792:0;;;;;:::i;:::-;;:::i;99060:100::-;;;;;;;;;;-1:-1:-1;99137:15:0;;99060:100;;67330:189;;;;;;;;;;-1:-1:-1;67330:189:0;;;;;:::i;:::-;-1:-1:-1;;;;;67476:25:0;;;67452:4;67476:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;67330:189;96789:139;;;;;;;;;;-1:-1:-1;96789:139:0;;;;;:::i;:::-;;:::i;99905:2344::-;;;;;;:::i;:::-;;:::i;33679:238::-;;;;;;;;;;-1:-1:-1;33679:238:0;;;;;:::i;:::-;;:::i;81956:66::-;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;81956:66:0;;83617:124;;;;;;;;;;-1:-1:-1;83617:124:0;;;;;:::i;:::-;;:::i;61754:321::-;61872:4;-1:-1:-1;;;;;;61909:40:0;;-1:-1:-1;;;61909:40:0;;:105;;-1:-1:-1;;;;;;;61966:48:0;;-1:-1:-1;;;61966:48:0;61909:105;:158;;;-1:-1:-1;;;;;;;;;;58935:40:0;;;62031:36;61889:178;61754:321;-1:-1:-1;;61754:321:0:o;64990:100::-;65044:13;65077:5;65070:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64990:100;:::o;66618:220::-;66702:7;66727:16;66735:7;66727;:16::i;:::-;66722:64;;66752:34;;-1:-1:-1;;;66752:34:0;;;;;;;;;;;66722:64;-1:-1:-1;66806:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;66806:24:0;;66618:220::o;66119:433::-;66200:18;66215:2;66200:14;:18::i;:::-;66231:13;66247:24;66263:7;66247:15;:24::i;:::-;66231:40;;66292:5;-1:-1:-1;;;;;66286:11:0;:2;-1:-1:-1;;;;;66286:11:0;;66282:48;;66306:24;;-1:-1:-1;;;66306:24:0;;;;;;;;;;;66282:48;13952:10;-1:-1:-1;;;;;66347:21:0;;;66343:161;;66388:37;66405:5;13952:10;67330:189;:::i;66388:37::-;66383:121;;66453:35;;-1:-1:-1;;;66453:35:0;;;;;;;;;;;66383:121;66516:28;66525:2;66529:7;66538:5;66516:8;:28::i;:::-;66189:363;66119:433;;:::o;99558:339::-;-1:-1:-1;;;;;99700:29:0;;99676:7;99700:29;;;:12;:29;;;;;;:34;;99696:75;;-1:-1:-1;99758:1:0;99751:8;;99696:75;-1:-1:-1;;;;;99846:34:0;;;;;;:17;:34;;;;;;;:43;;;;;;;;;99801:29;;;:12;:29;;;;;;:88;;99846:43;99801:88;:::i;:::-;99781:108;99558:339;-1:-1:-1;;;99558:339:0:o;97810:446::-;83109:24;13952:10;83234:130;:::i;83109:24::-;83087:119;;;;-1:-1:-1;;;83087:119:0;;;;;;;:::i;:::-;;;;;;;;;97927:7:::1;97922:236;97940:6;:13;97936:1;:17;;;97922:236;;;97975:12;97997:6;98004:1;97997:9;;;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;98034:30:::1;::::0;-1:-1:-1;;;98034:30:0;;98058:4:::1;98034:30;::::0;::::1;1878:51:1::0;97997:9:0;;-1:-1:-1;98022:9:0::1;::::0;-1:-1:-1;;;;;98034:15:0;::::1;::::0;::::1;::::0;1851:18:1;;98034:30:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;98022:42:::0;-1:-1:-1;98083:5:0;;98079:68:::1;;98109:22;::::0;-1:-1:-1;;;98109:22:0;;-1:-1:-1;;;;;17385:32:1;;;98109:22:0::1;::::0;::::1;17367:51:1::0;17434:18;;;17427:34;;;98109:14:0;::::1;::::0;::::1;::::0;17340:18:1;;98109:22:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;98079:68;97960:198;;97955:3;;;;;:::i;:::-;;;;97922:236;;;-1:-1:-1::0;98218:30:0::1;::::0;98186:21:::1;::::0;-1:-1:-1;;;;;98218:21:0;::::1;::::0;:30;::::1;;;::::0;98186:21;;98168:15:::1;98218:30:::0;98168:15;98218:30;98186:21;98218;:30;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;97911:345;97810:446:::0;;:::o;93390:922::-;12383:21;:19;:21::i;:::-;93535:1:::1;93526:5;:10;;93518:57;;;;-1:-1:-1::0;;;93518:57:0::1;;;;;;;:::i;:::-;93639:5;93623:13;;:21;;;;:::i;:::-;93610:9;:34;93588:118;;;;-1:-1:-1::0;;;93588:118:0::1;;;;;;;:::i;:::-;93727:12;::::0;::::1;;93719:47;;;;-1:-1:-1::0;;;93719:47:0::1;;;;;;;:::i;:::-;93801:158;93838:11;;93801:158;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;93868:18:0::1;::::0;93915:28:::1;::::0;93868:18;;-1:-1:-1;93915:28:0::1;::::0;-1:-1:-1;93932:10:0::1;::::0;93915:28:::1;;;:::i;:::-;;;;;;;;;;;;;93905:39;;;;;;93801:18;:158::i;:::-;93779:240;;;::::0;-1:-1:-1;;;93779:240:0;;19668:2:1;93779:240:0::1;::::0;::::1;19650:21:1::0;;;19687:18;;;19680:30;19746:34;19726:18;;;19719:62;19798:18;;93779:240:0::1;19466:356:1::0;93779:240:0::1;94037:9;94032:273;94056:5;94052:1;:9;94032:273;;;94125:13;;94109;;:29;94083:118;;;;-1:-1:-1::0;;;94083:118:0::1;;;;;;;:::i;:::-;94218:25;13952:10:::0;94218:11:::1;:25::i;:::-;94276:13;::::0;:17:::1;::::0;94292:1:::1;94276:17;:::i;:::-;94260:13;:33:::0;94063:3;::::1;::::0;::::1;:::i;:::-;;;;94032:273;;;;12427:20:::0;11821:1;12947:7;:22;12764:213;90526:434;83109:24;13952:10;83234:130;:::i;83109:24::-;83087:119;;;;-1:-1:-1;;;83087:119:0;;;;;;;:::i;:::-;90750:13:::1;:28:::0;;;;90789:13:::1;:28:::0;;;;90828:16:::1;:34:::0;90873:17:::1;:36:::0;90920:15:::1;:32:::0;90526:434::o;67649:170::-;67783:28;67793:4;67799:2;67803:7;67783:9;:28::i;95250:633::-;12383:21;:19;:21::i;:::-;95341:1:::1;95332:5;:10;;95324:57;;;;-1:-1:-1::0;;;95324:57:0::1;;;;;;;:::i;:::-;95448:5;95429:16;;:24;;;;:::i;:::-;95416:9;:37;95394:121;;;;-1:-1:-1::0;;;95394:121:0::1;;;;;;;:::i;:::-;95536:15;::::0;;;::::1;;;95528:50;;;;-1:-1:-1::0;;;95528:50:0::1;;;;;;;:::i;:::-;95596:9;95591:285;95615:5;95611:1;:9;95591:285;;;95687:16;;95668;;:35;95642:124;;;;-1:-1:-1::0;;;95642:124:0::1;;;;;;;:::i;:::-;95783:25;13952:10:::0;94218:11:::1;:25::i;95783:::-;95844:16;::::0;:20:::1;::::0;95863:1:::1;95844:20;:::i;:::-;95825:16;:39:::0;95622:3;::::1;::::0;::::1;:::i;:::-;;;;95591:285;;;;12427:20:::0;11821:1;12947:7;:22;12764:213;12427:20;95250:633;:::o;91469:276::-;83109:24;13952:10;83234:130;:::i;83109:24::-;83087:119;;;;-1:-1:-1;;;83087:119:0;;;;;;;:::i;:::-;91625:13:::1;:28:::0;;;;91664:13:::1;:28:::0;91703:16:::1;:34:::0;91469:276::o;67890:185::-;68028:39;68045:4;68051:2;68055:7;68028:39;;;;;;;;;;;;:16;:39::i;96691:90::-;83109:24;13952:10;83234:130;:::i;83109:24::-;83087:119;;;;-1:-1:-1;;;83087:119:0;;;;;;;:::i;:::-;96753:20:::1;96765:7;96753:11;:20::i;99225:166::-:0;83109:24;13952:10;83234:130;:::i;83109:24::-;83087:119;;;;-1:-1:-1;;;83087:119:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;99346:29:0;;::::1;;::::0;;;:12:::1;:29;::::0;;;;:37;99225:166::o;92088:391::-;83109:24;13952:10;83234:130;:::i;83109:24::-;83087:119;;;;-1:-1:-1;;;83087:119:0;;;;;;;:::i;:::-;92285:12:::1;:26:::0;;92402:13:::1;:28:::0;;-1:-1:-1;;92402:28:0::1;::::0;::::1;;::::0;;;::::1;::::0;;;-1:-1:-1;;92322:26:0;;;92285;::::1;;-1:-1:-1::0;;92322:26:0;;;;;92285::::1;92322::::0;::::1;;::::0;;;::::1;::::0;;;::::1;-1:-1:-1::0;;92441:30:0;92359:32;;::::1;;::::0;;;::::1;-1:-1:-1::0;;92441:30:0;;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;92088:391::o;64798:125::-;64862:7;64889:21;64902:7;64889:12;:21::i;:::-;:26;;64798:125;-1:-1:-1;;64798:125:0:o;83234:130::-;83301:4;83325:31;-1:-1:-1;;;;;;;;;;;83348:7:0;83325;:31::i;89015:79::-;83109:24;13952:10;83234:130;:::i;83109:24::-;83087:119;;;;-1:-1:-1;;;83087:119:0;;;;;;;:::i;:::-;89074:5:::1;:12:::0;;;::::1;;;;-1:-1:-1::0;;89074:12:0;;::::1;::::0;;;::::1;::::0;;89015:79::o;62139:206::-;62203:7;-1:-1:-1;;;;;62227:19:0;;62223:60;;62255:28;;-1:-1:-1;;;62255:28:0;;;;;;;;;;;62223:60;-1:-1:-1;;;;;;62309:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;62309:27:0;;62139:206::o;33421:103::-;32666:13;:11;:13::i;:::-;33486:30:::1;33513:1;33486:18;:30::i;:::-;33421:103::o:0;89747:228::-;83109:24;13952:10;83234:130;:::i;83109:24::-;83087:119;;;;-1:-1:-1;;;83087:119:0;;;;;;;:::i;:::-;89880:18:::1;:38:::0;;;;89929:18:::1;:38:::0;89747:228::o;89983:535::-;90120:19;90141;90190:145;90223:14;;90190:145;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;90252:18:0;;90295:28;;90252:18;;-1:-1:-1;90295:28:0;;-1:-1:-1;90312:10:0;;90295:28;;;:::i;90190:145::-;90173:162;;90365:145;90398:14;;90365:145;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;90427:18:0;;90470:28;;90427:18;;-1:-1:-1;90470:28:0;;-1:-1:-1;90487:10:0;;90470:28;;;:::i;90365:145::-;90348:162;;89983:535;;;;;;;:::o;82031:164::-;82134:4;82158:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;82158:29:0;;;;;;;;;;;;;;;82031:164::o;65159:104::-;65215:13;65248:7;65241:14;;;;;:::i;83489:120::-;83109:24;13952:10;83234:130;:::i;83109:24::-;83087:119;;;;-1:-1:-1;;;83087:119:0;;;;;;;:::i;:::-;83567:34:::1;-1:-1:-1::0;;;;;;;;;;;83593:7:0::1;83567:10;:34::i;97299:100::-:0;83109:24;13952:10;83234:130;:::i;83109:24::-;83087:119;;;;-1:-1:-1;;;83087:119:0;;;;;;;:::i;:::-;97373:18;;::::1;::::0;:8:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;:::-;;97299:100:::0;:::o;66910:349::-;67030:24;67045:8;67030:14;:24::i;:::-;13952:10;-1:-1:-1;;;;;67071:24:0;;;67067:54;;67104:17;;-1:-1:-1;;;67104:17:0;;;;;;;;;;;67067:54;13952:10;67134:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;67134:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;67134:53:0;;;;;;;;;;67203:48;;540:41:1;;;67134:42:0;;13952:10;67203:48;;513:18:1;67203:48:0;;;;;;;66910:349;;:::o;98930:122::-;83109:24;13952:10;83234:130;:::i;83109:24::-;83087:119;;;;-1:-1:-1;;;83087:119:0;;;;;;;:::i;:::-;99012:15:::1;:32:::0;98930:122::o;68146:392::-;68313:28;68323:4;68329:2;68333:7;68313:9;:28::i;:::-;-1:-1:-1;;;;;68356:13:0;;35959:19;:23;68352:179;;68391:56;68422:4;68428:2;68432:7;68441:5;68391:30;:56::i;:::-;68386:145;;68475:40;;-1:-1:-1;;;68475:40:0;;;;;;;;;;;94320:922;12383:21;:19;:21::i;:::-;94465:1:::1;94456:5;:10;;94448:57;;;;-1:-1:-1::0;;;94448:57:0::1;;;;;;;:::i;:::-;94569:5;94553:13;;:21;;;;:::i;:::-;94540:9;:34;94518:118;;;;-1:-1:-1::0;;;94518:118:0::1;;;;;;;:::i;:::-;94657:12;::::0;::::1;::::0;::::1;;;94649:47;;;;-1:-1:-1::0;;;94649:47:0::1;;;;;;;:::i;:::-;94731:158;94768:11;;94731:158;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;94798:18:0::1;::::0;94845:28:::1;::::0;94798:18;;-1:-1:-1;94845:28:0::1;::::0;-1:-1:-1;94862:10:0::1;::::0;94845:28:::1;;;:::i;94731:158::-;94709:240;;;::::0;-1:-1:-1;;;94709:240:0;;19668:2:1;94709:240:0::1;::::0;::::1;19650:21:1::0;;;19687:18;;;19680:30;19746:34;19726:18;;;19719:62;19798:18;;94709:240:0::1;19466:356:1::0;94709:240:0::1;94967:9;94962:273;94986:5;94982:1;:9;94962:273;;;95055:13;;95039;;:29;95013:118;;;;-1:-1:-1::0;;;95013:118:0::1;;;;;;;:::i;:::-;95148:25;13952:10:::0;94218:11:::1;:25::i;95148:::-;95206:13;::::0;:17:::1;::::0;95222:1:::1;95206:17;:::i;:::-;95190:13;:33:::0;94993:3;::::1;::::0;::::1;:::i;:::-;;;;94962:273;;97407:202:::0;97488:13;97558:8;97573:17;97582:7;97573:8;:17::i;:::-;97541:59;;;;;;;;;:::i;:::-;;;;;;;;;;;;;97514:87;;97407:202;;;:::o;95891:792::-;83109:24;13952:10;83234:130;:::i;83109:24::-;83087:119;;;;-1:-1:-1;;;83087:119:0;;;;;;;:::i;:::-;96069:7:::1;:14;96047:11;:18;:36;96025:146;;;::::0;-1:-1:-1;;;96025:146:0;;22649:2:1;96025:146:0::1;::::0;::::1;22631:21:1::0;22688:2;22668:18;;;22661:30;22727:34;22707:18;;;22700:62;22798:30;22778:18;;;22771:58;22846:19;;96025:146:0::1;22447:424:1::0;96025:146:0::1;96199:18:::0;;96184:12:::1;96228:448;96250:4;96245:2;:9;96228:448;;;96277:10;96290:11;96302:2;96290:15;;;;;;;;:::i;:::-;;;;;;;96277:28;;96320:14;96337:7;96345:2;96337:11;;;;;;;;:::i;:::-;;;;;;;96320:28;;96370:9;96365:300;96389:6;96385:1;:10;96365:300;;;96466:12;;96451;;:27;96421:139;;;;-1:-1:-1::0;;;96421:139:0::1;;;;;;;:::i;:::-;96581:16;96591:2;96595:1;96581:9;:16::i;:::-;96633:12;::::0;:16:::1;::::0;96648:1:::1;96633:16;:::i;:::-;96618:12;:31:::0;96397:3;::::1;::::0;::::1;:::i;:::-;;;;96365:300;;;;96262:414;;96256:4;;;;;:::i;:::-;;;;96228:448;;96789:139:::0;-1:-1:-1;;;;;96898:22:0;;96851:7;96898:22;;;:16;:22;;;;;;96878:17;;:42;;96898:22;96878:42;:::i;99905:2344::-;12383:21;:19;:21::i;:::-;100119:8:::1;:15;100099:9;:16;:35;100077:145;;;::::0;-1:-1:-1;;;100077:145:0;;23485:2:1;100077:145:0::1;::::0;::::1;23467:21:1::0;23524:2;23504:18;;;23497:30;23563:34;23543:18;;;23536:62;23634:30;23614:18;;;23607:58;23682:19;;100077:145:0::1;23283:424:1::0;100077:145:0::1;100276:6;:13;100257:8;:15;:32;100235:139;;;::::0;-1:-1:-1;;;100235:139:0;;23914:2:1;100235:139:0::1;::::0;::::1;23896:21:1::0;23953:2;23933:18;;;23926:30;23992:34;23972:18;;;23965:62;24063:27;24043:18;;;24036:55;24108:19;;100235:139:0::1;23712:421:1::0;100235:139:0::1;100395:14;::::0;;;::::1;;;100387:49;;;::::0;-1:-1:-1;;;100387:49:0;;24340:2:1;100387:49:0::1;::::0;::::1;24322:21:1::0;24379:2;24359:18;;;24352:30;-1:-1:-1;;;24398:18:1;;;24391:52;24460:18;;100387:49:0::1;24138:346:1::0;100387:49:0::1;100449:22;100491:9:::0;100486:116:::1;100510:8;:15;100506:1;:19;100486:116;;;100581:6;100588:1;100581:9;;;;;;;;:::i;:::-;;;;;;;100564:14;:26;;;;:::i;:::-;100547:43:::0;-1:-1:-1;100527:3:0;::::1;::::0;::::1;:::i;:::-;;;;100486:116;;;;100639:2;100622:14;:19;100614:53;;;::::0;-1:-1:-1;;;100614:53:0;;24691:2:1;100614:53:0::1;::::0;::::1;24673:21:1::0;24730:2;24710:18;;;24703:30;-1:-1:-1;;;24749:18:1;;;24742:51;24810:18;;100614:53:0::1;24489:345:1::0;100614:53:0::1;100733:14;100715:15;;:32;;;;:::i;:::-;100702:9;:45;100680:129;;;::::0;-1:-1:-1;;;100680:129:0;;25041:2:1;100680:129:0::1;::::0;::::1;25023:21:1::0;25080:2;25060:18;;;25053:30;25119:34;25099:18;;;25092:62;-1:-1:-1;;;25170:18:1;;;25163:32;25212:19;;100680:129:0::1;24839:398:1::0;100680:129:0::1;100827:9;100822:1420;100846:8;:15;100842:1;:19;100822:1420;;;100883:23;100909:9;100919:1;100909:12;;;;;;;;:::i;:::-;;;;;;;100883:38;;100936:15;100954:8;100963:1;100954:11;;;;;;;;:::i;:::-;;;;;;;100936:29;;100980:17;101000:6;101007:1;101000:9;;;;;;;;:::i;:::-;;;;;;;100980:29;;101097:10;-1:-1:-1::0;;;;;101052:55:0::1;101060:15;-1:-1:-1::0;;;;;101052:32:0::1;;101085:7;101052:41;;;;;;;;;;;;;738:25:1::0;;726:2;711:18;;592:177;101052:41:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;101052:55:0::1;;101026:137;;;::::0;-1:-1:-1;;;101026:137:0;;25700:2:1;101026:137:0::1;::::0;::::1;25682:21:1::0;25739:2;25719:18;;;25712:30;-1:-1:-1;;;25758:18:1;;;25751:50;25818:18;;101026:137:0::1;25498:344:1::0;101026:137:0::1;-1:-1:-1::0;;;;;101206:29:0;::::1;101238:1;101206:29:::0;;;:12:::1;:29;::::0;;;;;101180:127:::1;;;::::0;-1:-1:-1;;;101180:127:0;;26049:2:1;101180:127:0::1;::::0;::::1;26031:21:1::0;;;26068:18;;;26061:30;26127:34;26107:18;;;26100:62;26179:18;;101180:127:0::1;25847:356:1::0;101180:127:0::1;-1:-1:-1::0;;;;;101430:29:0;::::1;;::::0;;;:12:::1;:29;::::0;;;;;;;;101350:34;;;;;;:43;;;;;;;;;;:55:::1;::::0;101396:9;;101350:55:::1;:::i;:::-;:109;;101324:212;;;::::0;-1:-1:-1;;;101324:212:0;;26410:2:1;101324:212:0::1;::::0;::::1;26392:21:1::0;26449:2;26429:18;;;26422:30;26488:34;26468:18;;;26461:62;-1:-1:-1;;;26539:18:1;;;26532:39;26588:19;;101324:212:0::1;26208:405:1::0;101324:212:0::1;101607:12;;101594:9;101579:12;;:24;;;;:::i;:::-;:40;;101553:140;;;::::0;-1:-1:-1;;;101553:140:0;;26820:2:1;101553:140:0::1;::::0;::::1;26802:21:1::0;26859:2;26839:18;;;26832:30;26898:34;26878:18;;;26871:62;-1:-1:-1;;;26949:18:1;;;26942:36;26995:19;;101553:140:0::1;26618:402:1::0;101553:140:0::1;101767:15;;101754:9;101736:15;;:27;;;;:::i;:::-;:46;;101710:135;;;::::0;-1:-1:-1;;;101710:135:0;;27227:2:1;101710:135:0::1;::::0;::::1;27209:21:1::0;27266:2;27246:18;;;27239:30;27305:29;27285:18;;;27278:57;27352:18;;101710:135:0::1;27025:351:1::0;101710:135:0::1;101867:9;101862:99;101886:9;101882:1;:13;101862:99;;;101921:24;101931:10;101943:1;101921:9;:24::i;:::-;101897:3:::0;::::1;::::0;::::1;:::i;:::-;;;;101862:99;;;;102013:9;101995:15;;:27;;;;:::i;:::-;101977:15;:45:::0;102054:12:::1;::::0;:24:::1;::::0;102069:9;;102054:24:::1;:::i;:::-;102039:12;:39:::0;-1:-1:-1;;;;;102158:34:0;::::1;;::::0;;;:17:::1;:34:::0;;;;;;;:43;;;;;;;;;:72:::1;::::0;102221:9;;102158:72:::1;:::i;:::-;-1:-1:-1::0;;;;;102095:34:0;;::::1;;::::0;;;:17:::1;:34:::0;;;;;;;:43;;;;;;;;;;:135;;;;-1:-1:-1;100863:3:0;::::1;::::0;::::1;:::i;:::-;;;;100822:1420;;;;100066:2183;12427:20:::0;11821:1;12947:7;:22;12764:213;33679:238;32666:13;:11;:13::i;:::-;-1:-1:-1;;;;;33782:22:0;::::1;33760:110;;;::::0;-1:-1:-1;;;33760:110:0;;27583:2:1;33760:110:0::1;::::0;::::1;27565:21:1::0;27622:2;27602:18;;;27595:30;27661:34;27641:18;;;27634:62;-1:-1:-1;;;27712:18:1;;;27705:36;27758:19;;33760:110:0::1;27381:402:1::0;33760:110:0::1;33881:28;33900:8;33881:18;:28::i;83617:124::-:0;83109:24;13952:10;83234:130;:::i;83109:24::-;83087:119;;;;-1:-1:-1;;;83087:119:0;;;;;;;:::i;:::-;83698:35:::1;-1:-1:-1::0;;;;;;;;;;;83725:7:0::1;83698:11;:35::i;68793:213::-:0;68850:4;68940:13;;68930:7;:23;68887:111;;;;-1:-1:-1;;68971:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;68971:27:0;;;;68970:28;;68793:213::o;97170:121::-;97248:5;;;;;;;97240:43;;;;-1:-1:-1;;;97240:43:0;;27990:2:1;97240:43:0;;;27972:21:1;28029:2;28009:18;;;28002:30;28068:27;28048:18;;;28041:55;28113:18;;97240:43:0;27788:349:1;78073:162:0;78154:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;78154:29:0;-1:-1:-1;;;;;78154:29:0;;;;;;;;;78199:28;;78154:24;;78199:28;;;;;;;78073:162;;;:::o;12463:293::-;11865:1;12597:7;;:19;12589:63;;;;-1:-1:-1;;;12589:63:0;;28344:2:1;12589:63:0;;;28326:21:1;28383:2;28363:18;;;28356:30;28422:33;28402:18;;;28395:61;28473:18;;12589:63:0;28142:355:1;12589:63:0;11865:1;12730:7;:18;12463:293::o;1180:190::-;1305:4;1358;1329:25;1342:5;1349:4;1329:12;:25::i;:::-;:33;;1180:190;-1:-1:-1;;;;1180:190:0:o;92945:437::-;93043:17;;-1:-1:-1;;;;;93020:20:0;;;;;;:16;:20;;;;;;:40;92998:117;;;;-1:-1:-1;;;92998:117:0;;28704:2:1;92998:117:0;;;28686:21:1;28743:2;28723:18;;;28716:30;28782:29;28762:18;;;28755:57;28829:18;;92998:117:0;28502:351:1;92998:117:0;93163:12;;93148;;:27;93126:115;;;;-1:-1:-1;;;93126:115:0;;;;;;;:::i;:::-;93254:16;93264:2;93268:1;93254:9;:16::i;:::-;-1:-1:-1;;;;;93306:20:0;;;;;;:16;:20;;;;;;:24;;93329:1;93306:24;:::i;:::-;-1:-1:-1;;;;;93283:20:0;;;;;;:16;:20;;;;;:47;93358:12;;:16;;93373:1;93358:16;:::i;:::-;93343:12;:31;-1:-1:-1;92945:437:0:o;73119:2096::-;73200:35;73238:21;73251:7;73238:12;:21::i;:::-;73200:59;;73298:4;-1:-1:-1;;;;;73276:26:0;:13;:18;;;-1:-1:-1;;;;;73276:26:0;;73272:67;;73311:28;;-1:-1:-1;;;73311:28:0;;;;;;;;;;;73272:67;73352:22;13952:10;-1:-1:-1;;;;;73378:20:0;;;;:73;;-1:-1:-1;73415:36:0;73432:4;13952:10;67330:189;:::i;73415:36::-;73378:126;;;-1:-1:-1;13952:10:0;73468:20;73480:7;73468:11;:20::i;:::-;-1:-1:-1;;;;;73468:36:0;;73378:126;73352:153;;73523:17;73518:66;;73549:35;;-1:-1:-1;;;73549:35:0;;;;;;;;;;;73518:66;-1:-1:-1;;;;;73599:16:0;;73595:52;;73624:23;;-1:-1:-1;;;73624:23:0;;;;;;;;;;;73595:52;73660:43;73682:4;73688:2;73692:7;73701:1;73660:21;:43::i;:::-;73768:35;73785:1;73789:7;73798:4;73768:8;:35::i;:::-;-1:-1:-1;;;;;74099:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;74099:31:0;;;-1:-1:-1;;;;;74099:31:0;;;-1:-1:-1;;74099:31:0;;;;;;;74145:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;74145:29:0;;;;;;;;;;;74225:20;;;:11;:20;;;;;;74260:18;;-1:-1:-1;;;;;;74293:49:0;;;;-1:-1:-1;;;74326:15:0;74293:49;;;;;;;;;;74616:11;;74676:24;;;;;74719:13;;74225:20;;74676:24;;74719:13;74715:384;;74929:13;;74914:11;:28;74910:174;;74967:20;;75036:28;;;;-1:-1:-1;;;;;75010:54:0;-1:-1:-1;;;75010:54:0;-1:-1:-1;;;;;;75010:54:0;;;-1:-1:-1;;;;;74967:20:0;;75010:54;;;;74910:174;74074:1036;;;75146:7;75142:2;-1:-1:-1;;;;;75127:27:0;75136:4;-1:-1:-1;;;;;75127:27:0;-1:-1:-1;;;;;;;;;;;75127:27:0;;;;;;;;;73189:2026;;73119:2096;;;:::o;75293:89::-;75353:21;75359:7;75368:5;75353;:21::i;63520:1216::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;63647:7:0;63749:13;;63742:4;:20;63738:931;;;63787:31;63821:17;;;:11;:17;;;;;;;;;63787:51;;;;;;;;;-1:-1:-1;;;;;63787:51:0;;;;-1:-1:-1;;;63787:51:0;;-1:-1:-1;;;;;63787:51:0;;;;;;;;-1:-1:-1;;;63787:51:0;;;;;;;;;;;;;;63861:789;;63915:14;;-1:-1:-1;;;;;63915:28:0;;63911:109;;63983:9;63520:1216;-1:-1:-1;;;63520:1216:0:o;63911:109::-;-1:-1:-1;;;64386:6:0;64435:17;;;;:11;:17;;;;;;;;;64423:29;;;;;;;;;-1:-1:-1;;;;;64423:29:0;;;;;-1:-1:-1;;;64423:29:0;;-1:-1:-1;;;;;64423:29:0;;;;;;;;-1:-1:-1;;;64423:29:0;;;;;;;;;;;;;64487:28;64483:117;;64559:9;63520:1216;-1:-1:-1;;;63520:1216:0:o;64483:117::-;64342:285;;;63764:905;63738:931;64697:31;;-1:-1:-1;;;64697:31:0;;;;;;;;;;;32945:132;32853:6;;-1:-1:-1;;;;;32853:6:0;13952:10;33009:23;33001:68;;;;-1:-1:-1;;;33001:68:0;;29060:2:1;33001:68:0;;;29042:21:1;;;29079:18;;;29072:30;29138:34;29118:18;;;29111:62;29190:18;;33001:68:0;28858:356:1;34077:191:0;34170:6;;;-1:-1:-1;;;;;34187:17:0;;;-1:-1:-1;;;;;;34187:17:0;;;;;;;34220:40;;34170:6;;;34187:17;34170:6;;34220:40;;34151:16;;34220:40;34140:128;34077:191;:::o;82203:229::-;82278:22;82286:4;82292:7;82278;:22::i;:::-;82273:152;;82317:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;82317:29:0;;;;;;;;;:36;;-1:-1:-1;;82317:36:0;82349:4;82317:36;;;82400:12;13952:10;;13872:98;82400:12;-1:-1:-1;;;;;82373:40:0;82391:7;-1:-1:-1;;;;;82373:40:0;82385:4;82373:40;;;;;;;;;;82203:229;;:::o;78727:772::-;78924:155;;-1:-1:-1;;;78924:155:0;;78890:4;;-1:-1:-1;;;;;78924:36:0;;;;;:155;;13952:10;;79010:4;;79033:7;;79059:5;;78924:155;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;78924:155:0;;;;;;;;-1:-1:-1;;78924:155:0;;;;;;;;;;;;:::i;:::-;;;78907:585;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79250:6;:13;79267:1;79250:18;79246:235;;79296:40;;-1:-1:-1;;;79296:40:0;;;;;;;;;;;79246:235;79439:6;79433:13;79424:6;79420:2;79416:15;79409:38;78907:585;-1:-1:-1;;;;;;79135:55:0;-1:-1:-1;;;79135:55:0;;-1:-1:-1;78907:585:0;78727:772;;;;;;:::o;98264:532::-;98320:13;98350:5;98359:1;98350:10;98346:53;;-1:-1:-1;;98377:10:0;;;;;;;;;;;;-1:-1:-1;;;98377:10:0;;;;;98264:532::o;98346:53::-;98424:5;98409:12;98465:78;98472:9;;98465:78;;98498:8;;;;:::i;:::-;;-1:-1:-1;98521:10:0;;-1:-1:-1;98529:2:0;98521:10;;:::i;:::-;;;98465:78;;;98553:19;98585:6;-1:-1:-1;;;;;98575:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;98575:17:0;;98553:39;;98603:154;98610:10;;98603:154;;98637:11;98647:1;98637:11;;:::i;:::-;;-1:-1:-1;98706:10:0;98714:2;98706:5;:10;:::i;:::-;98693:24;;:2;:24;:::i;:::-;98680:39;;98663:6;98670;98663:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;98663:56:0;;;;;;;;-1:-1:-1;98734:11:0;98743:2;98734:11;;:::i;:::-;;;98603:154;;69090:104;69159:27;69169:2;69173:8;69159:27;;;;;;;;;;;;:9;:27::i;82560:230::-;82635:22;82643:4;82649:7;82635;:22::i;:::-;82631:152;;;82706:5;82674:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;82674:29:0;;;;;;;;;;:37;;-1:-1:-1;;82674:37:0;;;82731:40;13952:10;;82674:12;;82731:40;;82706:5;82731:40;82560:230;;:::o;2047:321::-;2155:7;2198:4;2155:7;2213:118;2237:5;:12;2233:1;:16;2213:118;;;2286:33;2296:12;2310:5;2316:1;2310:8;;;;;;;;:::i;:::-;;;;;;;2286:9;:33::i;:::-;2271:48;-1:-1:-1;2251:3:0;;;;:::i;:::-;;;;2213:118;;;-1:-1:-1;2348:12:0;2047:321;-1:-1:-1;;;2047:321:0:o;96936:226::-;97118:5;;;;;;;97110:44;;;;-1:-1:-1;;;97110:44:0;;30554:2:1;97110:44:0;;;30536:21:1;30593:2;30573:18;;;30566:30;30632:28;30612:18;;;30605:56;30678:18;;97110:44:0;30352:350:1;75611:2344:0;75691:35;75729:21;75742:7;75729:12;:21::i;:::-;75778:18;;75691:59;;-1:-1:-1;75809:290:0;;;;75843:22;13952:10;-1:-1:-1;;;;;75869:20:0;;;;:77;;-1:-1:-1;75910:36:0;75927:4;13952:10;67330:189;:::i;75910:36::-;75869:134;;;-1:-1:-1;13952:10:0;75967:20;75979:7;75967:11;:20::i;:::-;-1:-1:-1;;;;;75967:36:0;;75869:134;75843:161;;76026:17;76021:66;;76052:35;;-1:-1:-1;;;76052:35:0;;;;;;;;;;;76021:66;75828:271;75809:290;76163:35;76180:1;76184:7;76193:4;76163:8;:35::i;:::-;-1:-1:-1;;;;;76528:18:0;;;76494:31;76528:18;;;:12;:18;;;;;;;;76561:24;;-1:-1:-1;;;;;;;;;;76561:24:0;;;;;;;;;-1:-1:-1;;76561:24:0;;;;76600:29;;;;;76584:1;76600:29;;;;;;;;-1:-1:-1;;76600:29:0;;;;;;;;;;76762:20;;;:11;:20;;;;;;76797;;-1:-1:-1;;;;76865:15:0;76832:49;;;-1:-1:-1;;;76832:49:0;-1:-1:-1;;;;;;76832:49:0;;;;;;;;;;76896:22;-1:-1:-1;;;76896:22:0;;;77188:11;;;77248:24;;;;;77291:13;;76528:18;;77248:24;;77291:13;77287:384;;77501:13;;77486:11;:28;77482:174;;77539:20;;77608:28;;;;-1:-1:-1;;;;;77582:54:0;-1:-1:-1;;;77582:54:0;-1:-1:-1;;;;;;77582:54:0;;;-1:-1:-1;;;;;77539:20:0;;77582:54;;;;77482:174;-1:-1:-1;;77699:35:0;;77726:7;;-1:-1:-1;77722:1:0;;-1:-1:-1;;;;;;77699:35:0;;;-1:-1:-1;;;;;;;;;;;77699:35:0;77722:1;;77699:35;-1:-1:-1;;77922:12:0;:14;;;;;;-1:-1:-1;;75611:2344:0:o;69567:1866::-;69690:20;69713:13;-1:-1:-1;;;;;69741:16:0;;69737:48;;69766:19;;-1:-1:-1;;;69766:19:0;;;;;;;;;;;69737:48;69800:8;69812:1;69800:13;69796:44;;69822:18;;-1:-1:-1;;;69822:18:0;;;;;;;;;;;69796:44;-1:-1:-1;;;;;70117:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;70176:49:0;;-1:-1:-1;;;;;70117:44:0;;;;;;;70176:49;;;;-1:-1:-1;;70117:44:0;;;;;;70176:49;;;;;;;;;;;;;;;;70242:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;70292:66:0;;;-1:-1:-1;;;70342:15:0;70292:66;;;;;;;;;;;;;70242:25;;70439:23;;;;35959:19;:23;70479:822;;70519:504;70550:38;;70575:12;;-1:-1:-1;;;;;70550:38:0;;;70567:1;;-1:-1:-1;;;;;;;;;;;70550:38:0;70567:1;;70550:38;70642:212;70711:1;70744:2;70777:14;;;;;;70822:5;70642:30;:212::i;:::-;70611:365;;70912:40;;-1:-1:-1;;;70912:40:0;;;;;;;;;;;70611:365;71018:3;71003:12;:18;70519:504;;71104:12;71087:13;;:29;71083:43;;71118:8;;;71083:43;70479:822;;;71167:119;71198:40;;71223:14;;;;;-1:-1:-1;;;;;71198:40:0;;;71215:1;;-1:-1:-1;;;;;;;;;;;71198:40:0;71215:1;;71198:40;71281:3;71266:12;:18;71167:119;;70479:822;-1:-1:-1;71315:13:0;:28;;;71365:60;;71398:2;71402:12;71416:8;71365:60;:::i;9677:149::-;9740:7;9771:1;9767;:5;:51;;9927:13;10021:15;;;10057:4;10050:15;;;10104:4;10088:21;;9767:51;;;9927:13;10021:15;;;10057:4;10050:15;;;10104:4;10088:21;;9775:20;9834:293;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;774:258::-;846:1;856:113;870:6;867:1;864:13;856:113;;;946:11;;;940:18;927:11;;;920:39;892:2;885:10;856:113;;;987:6;984:1;981:13;978:48;;;-1:-1:-1;;1022:1:1;1004:16;;997:27;774:258::o;1037:269::-;1090:3;1128:5;1122:12;1155:6;1150:3;1143:19;1171:63;1227:6;1220:4;1215:3;1211:14;1204:4;1197:5;1193:16;1171:63;:::i;:::-;1288:2;1267:15;-1:-1:-1;;1263:29:1;1254:39;;;;1295:4;1250:50;;1037:269;-1:-1:-1;;1037:269:1:o;1311:231::-;1460:2;1449:9;1442:21;1423:4;1480:56;1532:2;1521:9;1517:18;1509:6;1480:56;:::i;1547:180::-;1606:6;1659:2;1647:9;1638:7;1634:23;1630:32;1627:52;;;1675:1;1672;1665:12;1627:52;-1:-1:-1;1698:23:1;;1547:180;-1:-1:-1;1547:180:1:o;1940:131::-;-1:-1:-1;;;;;2015:31:1;;2005:42;;1995:70;;2061:1;2058;2051:12;2076:315;2144:6;2152;2205:2;2193:9;2184:7;2180:23;2176:32;2173:52;;;2221:1;2218;2211:12;2173:52;2260:9;2247:23;2279:31;2304:5;2279:31;:::i;:::-;2329:5;2381:2;2366:18;;;;2353:32;;-1:-1:-1;;;2076:315:1:o;2396:127::-;2457:10;2452:3;2448:20;2445:1;2438:31;2488:4;2485:1;2478:15;2512:4;2509:1;2502:15;2528:275;2599:2;2593:9;2664:2;2645:13;;-1:-1:-1;;2641:27:1;2629:40;;-1:-1:-1;;;;;2684:34:1;;2720:22;;;2681:62;2678:88;;;2746:18;;:::i;:::-;2782:2;2775:22;2528:275;;-1:-1:-1;2528:275:1:o;2808:183::-;2868:4;-1:-1:-1;;;;;2893:6:1;2890:30;2887:56;;;2923:18;;:::i;:::-;-1:-1:-1;2968:1:1;2964:14;2980:4;2960:25;;2808:183::o;2996:737::-;3050:5;3103:3;3096:4;3088:6;3084:17;3080:27;3070:55;;3121:1;3118;3111:12;3070:55;3157:6;3144:20;3183:4;3207:60;3223:43;3263:2;3223:43;:::i;:::-;3207:60;:::i;:::-;3301:15;;;3387:1;3383:10;;;;3371:23;;3367:32;;;3332:12;;;;3411:15;;;3408:35;;;3439:1;3436;3429:12;3408:35;3475:2;3467:6;3463:15;3487:217;3503:6;3498:3;3495:15;3487:217;;;3583:3;3570:17;3600:31;3625:5;3600:31;:::i;:::-;3644:18;;3682:12;;;;3520;;3487:217;;;-1:-1:-1;3722:5:1;2996:737;-1:-1:-1;;;;;;2996:737:1:o;3738:483::-;3831:6;3839;3892:2;3880:9;3871:7;3867:23;3863:32;3860:52;;;3908:1;3905;3898:12;3860:52;3948:9;3935:23;-1:-1:-1;;;;;3973:6:1;3970:30;3967:50;;;4013:1;4010;4003:12;3967:50;4036:61;4089:7;4080:6;4069:9;4065:22;4036:61;:::i;:::-;4026:71;;;4147:2;4136:9;4132:18;4119:32;4160:31;4185:5;4160:31;:::i;:::-;4210:5;4200:15;;;3738:483;;;;;:::o;4226:367::-;4289:8;4299:6;4353:3;4346:4;4338:6;4334:17;4330:27;4320:55;;4371:1;4368;4361:12;4320:55;-1:-1:-1;4394:20:1;;-1:-1:-1;;;;;4426:30:1;;4423:50;;;4469:1;4466;4459:12;4423:50;4506:4;4498:6;4494:17;4482:29;;4566:3;4559:4;4549:6;4546:1;4542:14;4534:6;4530:27;4526:38;4523:47;4520:67;;;4583:1;4580;4573:12;4520:67;4226:367;;;;;:::o;4598:505::-;4693:6;4701;4709;4762:2;4750:9;4741:7;4737:23;4733:32;4730:52;;;4778:1;4775;4768:12;4730:52;4818:9;4805:23;-1:-1:-1;;;;;4843:6:1;4840:30;4837:50;;;4883:1;4880;4873:12;4837:50;4922:70;4984:7;4975:6;4964:9;4960:22;4922:70;:::i;:::-;5011:8;;4896:96;;-1:-1:-1;5093:2:1;5078:18;;;;5065:32;;4598:505;-1:-1:-1;;;;4598:505:1:o;5290:454::-;5385:6;5393;5401;5409;5417;5470:3;5458:9;5449:7;5445:23;5441:33;5438:53;;;5487:1;5484;5477:12;5438:53;-1:-1:-1;;5510:23:1;;;5580:2;5565:18;;5552:32;;-1:-1:-1;5631:2:1;5616:18;;5603:32;;5682:2;5667:18;;5654:32;;-1:-1:-1;5733:3:1;5718:19;5705:33;;-1:-1:-1;5290:454:1;-1:-1:-1;5290:454:1:o;5749:456::-;5826:6;5834;5842;5895:2;5883:9;5874:7;5870:23;5866:32;5863:52;;;5911:1;5908;5901:12;5863:52;5950:9;5937:23;5969:31;5994:5;5969:31;:::i;:::-;6019:5;-1:-1:-1;6076:2:1;6061:18;;6048:32;6089:33;6048:32;6089:33;:::i;:::-;5749:456;;6141:7;;-1:-1:-1;;;6195:2:1;6180:18;;;;6167:32;;5749:456::o;6210:316::-;6287:6;6295;6303;6356:2;6344:9;6335:7;6331:23;6327:32;6324:52;;;6372:1;6369;6362:12;6324:52;-1:-1:-1;;6395:23:1;;;6465:2;6450:18;;6437:32;;-1:-1:-1;6516:2:1;6501:18;;;6488:32;;6210:316;-1:-1:-1;6210:316:1:o;6999:118::-;7085:5;7078:13;7071:21;7064:5;7061:32;7051:60;;7107:1;7104;7097:12;7122:783;7202:6;7210;7218;7226;7234;7287:3;7275:9;7266:7;7262:23;7258:33;7255:53;;;7304:1;7301;7294:12;7255:53;7343:9;7330:23;7362:28;7384:5;7362:28;:::i;:::-;7409:5;-1:-1:-1;7466:2:1;7451:18;;7438:32;7479:30;7438:32;7479:30;:::i;:::-;7528:7;-1:-1:-1;7587:2:1;7572:18;;7559:32;7600:30;7559:32;7600:30;:::i;:::-;7649:7;-1:-1:-1;7708:2:1;7693:18;;7680:32;7721:30;7680:32;7721:30;:::i;:::-;7770:7;-1:-1:-1;7829:3:1;7814:19;;7801:33;7843:30;7801:33;7843:30;:::i;:::-;7892:7;7882:17;;;7122:783;;;;;;;;:::o;7910:247::-;7969:6;8022:2;8010:9;8001:7;7997:23;7993:32;7990:52;;;8038:1;8035;8028:12;7990:52;8077:9;8064:23;8096:31;8121:5;8096:31;:::i;8162:241::-;8218:6;8271:2;8259:9;8250:7;8246:23;8242:32;8239:52;;;8287:1;8284;8277:12;8239:52;8326:9;8313:23;8345:28;8367:5;8345:28;:::i;8408:248::-;8476:6;8484;8537:2;8525:9;8516:7;8512:23;8508:32;8505:52;;;8553:1;8550;8543:12;8505:52;-1:-1:-1;;8576:23:1;;;8646:2;8631:18;;;8618:32;;-1:-1:-1;8408:248:1:o;8661:773::-;8783:6;8791;8799;8807;8860:2;8848:9;8839:7;8835:23;8831:32;8828:52;;;8876:1;8873;8866:12;8828:52;8916:9;8903:23;-1:-1:-1;;;;;8986:2:1;8978:6;8975:14;8972:34;;;9002:1;8999;8992:12;8972:34;9041:70;9103:7;9094:6;9083:9;9079:22;9041:70;:::i;:::-;9130:8;;-1:-1:-1;9015:96:1;-1:-1:-1;9218:2:1;9203:18;;9190:32;;-1:-1:-1;9234:16:1;;;9231:36;;;9263:1;9260;9253:12;9231:36;;9302:72;9366:7;9355:8;9344:9;9340:24;9302:72;:::i;:::-;8661:773;;;;-1:-1:-1;9393:8:1;-1:-1:-1;;;;8661:773:1:o;10108:315::-;10176:6;10184;10237:2;10225:9;10216:7;10212:23;10208:32;10205:52;;;10253:1;10250;10243:12;10205:52;10289:9;10276:23;10266:33;;10349:2;10338:9;10334:18;10321:32;10362:31;10387:5;10362:31;:::i;10428:407::-;10493:5;-1:-1:-1;;;;;10519:6:1;10516:30;10513:56;;;10549:18;;:::i;:::-;10587:57;10632:2;10611:15;;-1:-1:-1;;10607:29:1;10638:4;10603:40;10587:57;:::i;:::-;10578:66;;10667:6;10660:5;10653:21;10707:3;10698:6;10693:3;10689:16;10686:25;10683:45;;;10724:1;10721;10714:12;10683:45;10773:6;10768:3;10761:4;10754:5;10750:16;10737:43;10827:1;10820:4;10811:6;10804:5;10800:18;10796:29;10789:40;10428:407;;;;;:::o;10840:451::-;10909:6;10962:2;10950:9;10941:7;10937:23;10933:32;10930:52;;;10978:1;10975;10968:12;10930:52;11018:9;11005:23;-1:-1:-1;;;;;11043:6:1;11040:30;11037:50;;;11083:1;11080;11073:12;11037:50;11106:22;;11159:4;11151:13;;11147:27;-1:-1:-1;11137:55:1;;11188:1;11185;11178:12;11137:55;11211:74;11277:7;11272:2;11259:16;11254:2;11250;11246:11;11211:74;:::i;11296:382::-;11361:6;11369;11422:2;11410:9;11401:7;11397:23;11393:32;11390:52;;;11438:1;11435;11428:12;11390:52;11477:9;11464:23;11496:31;11521:5;11496:31;:::i;:::-;11546:5;-1:-1:-1;11603:2:1;11588:18;;11575:32;11616:30;11575:32;11616:30;:::i;12525:795::-;12620:6;12628;12636;12644;12697:3;12685:9;12676:7;12672:23;12668:33;12665:53;;;12714:1;12711;12704:12;12665:53;12753:9;12740:23;12772:31;12797:5;12772:31;:::i;:::-;12822:5;-1:-1:-1;12879:2:1;12864:18;;12851:32;12892:33;12851:32;12892:33;:::i;:::-;12944:7;-1:-1:-1;12998:2:1;12983:18;;12970:32;;-1:-1:-1;13053:2:1;13038:18;;13025:32;-1:-1:-1;;;;;13069:30:1;;13066:50;;;13112:1;13109;13102:12;13066:50;13135:22;;13188:4;13180:13;;13176:27;-1:-1:-1;13166:55:1;;13217:1;13214;13207:12;13166:55;13240:74;13306:7;13301:2;13288:16;13283:2;13279;13275:11;13240:74;:::i;:::-;13230:84;;;12525:795;;;;;;;:::o;13325:662::-;13379:5;13432:3;13425:4;13417:6;13413:17;13409:27;13399:55;;13450:1;13447;13440:12;13399:55;13486:6;13473:20;13512:4;13536:60;13552:43;13592:2;13552:43;:::i;13536:60::-;13630:15;;;13716:1;13712:10;;;;13700:23;;13696:32;;;13661:12;;;;13740:15;;;13737:35;;;13768:1;13765;13758:12;13737:35;13804:2;13796:6;13792:15;13816:142;13832:6;13827:3;13824:15;13816:142;;;13898:17;;13886:30;;13936:12;;;;13849;;13816:142;;13992:595;14110:6;14118;14171:2;14159:9;14150:7;14146:23;14142:32;14139:52;;;14187:1;14184;14177:12;14139:52;14227:9;14214:23;-1:-1:-1;;;;;14297:2:1;14289:6;14286:14;14283:34;;;14313:1;14310;14303:12;14283:34;14336:61;14389:7;14380:6;14369:9;14365:22;14336:61;:::i;:::-;14326:71;;14450:2;14439:9;14435:18;14422:32;14406:48;;14479:2;14469:8;14466:16;14463:36;;;14495:1;14492;14485:12;14463:36;;14518:63;14573:7;14562:8;14551:9;14547:24;14518:63;:::i;:::-;14508:73;;;13992:595;;;;;:::o;14592:388::-;14660:6;14668;14721:2;14709:9;14700:7;14696:23;14692:32;14689:52;;;14737:1;14734;14727:12;14689:52;14776:9;14763:23;14795:31;14820:5;14795:31;:::i;:::-;14845:5;-1:-1:-1;14902:2:1;14887:18;;14874:32;14915:33;14874:32;14915:33;:::i;14985:821::-;15137:6;15145;15153;15206:2;15194:9;15185:7;15181:23;15177:32;15174:52;;;15222:1;15219;15212:12;15174:52;15262:9;15249:23;-1:-1:-1;;;;;15332:2:1;15324:6;15321:14;15318:34;;;15348:1;15345;15338:12;15318:34;15371:61;15424:7;15415:6;15404:9;15400:22;15371:61;:::i;:::-;15361:71;;15485:2;15474:9;15470:18;15457:32;15441:48;;15514:2;15504:8;15501:16;15498:36;;;15530:1;15527;15520:12;15498:36;15553:63;15608:7;15597:8;15586:9;15582:24;15553:63;:::i;:::-;15543:73;;15669:2;15658:9;15654:18;15641:32;15625:48;;15698:2;15688:8;15685:16;15682:36;;;15714:1;15711;15704:12;15682:36;;15737:63;15792:7;15781:8;15770:9;15766:24;15737:63;:::i;:::-;15727:73;;;14985:821;;;;;:::o;15811:380::-;15890:1;15886:12;;;;15933;;;15954:61;;16008:4;16000:6;15996:17;15986:27;;15954:61;16061:2;16053:6;16050:14;16030:18;16027:38;16024:161;;16107:10;16102:3;16098:20;16095:1;16088:31;16142:4;16139:1;16132:15;16170:4;16167:1;16160:15;16024:161;;15811:380;;;:::o;16196:127::-;16257:10;16252:3;16248:20;16245:1;16238:31;16288:4;16285:1;16278:15;16312:4;16309:1;16302:15;16328:125;16368:4;16396:1;16393;16390:8;16387:34;;;16401:18;;:::i;:::-;-1:-1:-1;16438:9:1;;16328:125::o;16458:409::-;16660:2;16642:21;;;16699:2;16679:18;;;16672:30;16738:34;16733:2;16718:18;;16711:62;-1:-1:-1;;;16804:2:1;16789:18;;16782:43;16857:3;16842:19;;16458:409::o;16872:127::-;16933:10;16928:3;16924:20;16921:1;16914:31;16964:4;16961:1;16954:15;16988:4;16985:1;16978:15;17004:184;17074:6;17127:2;17115:9;17106:7;17102:23;17098:32;17095:52;;;17143:1;17140;17133:12;17095:52;-1:-1:-1;17166:16:1;;17004:184;-1:-1:-1;17004:184:1:o;17472:245::-;17539:6;17592:2;17580:9;17571:7;17567:23;17563:32;17560:52;;;17608:1;17605;17598:12;17560:52;17640:9;17634:16;17659:28;17681:5;17659:28;:::i;17722:175::-;17759:3;17803:4;17796:5;17792:16;17832:4;17823:7;17820:17;17817:43;;17840:18;;:::i;:::-;17889:1;17876:15;;17722:175;-1:-1:-1;;17722:175:1:o;17902:398::-;18104:2;18086:21;;;18143:2;18123:18;;;18116:30;18182:34;18177:2;18162:18;;18155:62;-1:-1:-1;;;18248:2:1;18233:18;;18226:32;18290:3;18275:19;;17902:398::o;18305:168::-;18345:7;18411:1;18407;18403:6;18399:14;18396:1;18393:21;18388:1;18381:9;18374:17;18370:45;18367:71;;;18418:18;;:::i;:::-;-1:-1:-1;18458:9:1;;18305:168::o;18478:398::-;18680:2;18662:21;;;18719:2;18699:18;;;18692:30;18758:34;18753:2;18738:18;;18731:62;-1:-1:-1;;;18824:2:1;18809:18;;18802:32;18866:3;18851:19;;18478:398::o;18881:346::-;19083:2;19065:21;;;19122:2;19102:18;;;19095:30;-1:-1:-1;;;19156:2:1;19141:18;;19134:52;19218:2;19203:18;;18881:346::o;19232:229::-;19381:2;19377:15;;;;-1:-1:-1;;19373:53:1;19361:66;;19452:2;19443:12;;19232:229::o;19827:351::-;20029:2;20011:21;;;20068:2;20048:18;;;20041:30;20107:29;20102:2;20087:18;;20080:57;20169:2;20154:18;;19827:351::o;20183:128::-;20223:3;20254:1;20250:6;20247:1;20244:13;20241:39;;;20260:18;;:::i;:::-;-1:-1:-1;20296:9:1;;20183:128::o;20316:135::-;20355:3;20376:17;;;20373:43;;20396:18;;:::i;:::-;-1:-1:-1;20443:1:1;20432:13;;20316:135::o;20701:185::-;20743:3;20781:5;20775:12;20796:52;20841:6;20836:3;20829:4;20822:5;20818:16;20796:52;:::i;:::-;20864:16;;;;;20701:185;-1:-1:-1;;20701:185:1:o;21009:1433::-;21387:3;21416:1;21449:6;21443:13;21479:3;21501:1;21529:9;21525:2;21521:18;21511:28;;21589:2;21578:9;21574:18;21611;21601:61;;21655:4;21647:6;21643:17;21633:27;;21601:61;21681:2;21729;21721:6;21718:14;21698:18;21695:38;21692:165;;-1:-1:-1;;;21756:33:1;;21812:4;21809:1;21802:15;21842:4;21763:3;21830:17;21692:165;21873:18;21900:104;;;;22018:1;22013:320;;;;21866:467;;21900:104;-1:-1:-1;;21933:24:1;;21921:37;;21978:16;;;;-1:-1:-1;21900:104:1;;22013:320;20529:1;20522:14;;;20566:4;20553:18;;22108:1;22122:165;22136:6;22133:1;22130:13;22122:165;;;22214:14;;22201:11;;;22194:35;22257:16;;;;22151:10;;22122:165;;;22126:3;;22316:6;22311:3;22307:16;22300:23;;21866:467;;;;;;;22349:87;22374:61;22400:34;22430:3;-1:-1:-1;;;20647:16:1;;20688:1;20679:11;;20582:114;22400:34;22392:6;22374:61;:::i;:::-;-1:-1:-1;;;20951:20:1;;20996:1;20987:11;;20891:113;22349:87;22342:94;21009:1433;-1:-1:-1;;;;;21009:1433:1:o;22876:402::-;23078:2;23060:21;;;23117:2;23097:18;;;23090:30;23156:34;23151:2;23136:18;;23129:62;-1:-1:-1;;;23222:2:1;23207:18;;23200:36;23268:3;23253:19;;22876:402::o;25242:251::-;25312:6;25365:2;25353:9;25344:7;25340:23;25336:32;25333:52;;;25381:1;25378;25371:12;25333:52;25413:9;25407:16;25432:31;25457:5;25432:31;:::i;29219:500::-;-1:-1:-1;;;;;29488:15:1;;;29470:34;;29540:15;;29535:2;29520:18;;29513:43;29587:2;29572:18;;29565:34;;;29635:3;29630:2;29615:18;;29608:31;;;29413:4;;29656:57;;29693:19;;29685:6;29656:57;:::i;:::-;29648:65;29219:500;-1:-1:-1;;;;;;29219:500:1:o;29724:249::-;29793:6;29846:2;29834:9;29825:7;29821:23;29817:32;29814:52;;;29862:1;29859;29852:12;29814:52;29894:9;29888:16;29913:30;29937:5;29913:30;:::i;29978:127::-;30039:10;30034:3;30030:20;30027:1;30020:31;30070:4;30067:1;30060:15;30094:4;30091:1;30084:15;30110:120;30150:1;30176;30166:35;;30181:18;;:::i;:::-;-1:-1:-1;30215:9:1;;30110:120::o;30235:112::-;30267:1;30293;30283:35;;30298:18;;:::i;:::-;-1:-1:-1;30332:9:1;;30235:112::o

Swarm Source

ipfs://00e1cd9a75170428bbbdcc0b66211306dcb2a915d7066efb599f22009883e459

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