Token

PocketwithLoveSBT (PocketwithLoveSBT)

ERC-721

Overview

Max Total Supply

113 PocketwithLoveSBT

Holders

110

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x0795d136c053ebdd25966a54608309d5ae650afc

Filtered by Token Holder

0x98BE6908C2E88886C137D73B97Ffe38a5877cf45

leesp.eth

Balance

1 PocketwithLoveSBT

0x98be6908c2e88886c137d73b97ffe38a5877cf45

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

PocketwithLoveSBT

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-02
*/

pragma solidity 0.8.13;

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

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

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

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

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

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

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function 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 totalHashes = proofFlags.length;

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

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

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

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value 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) {
            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 PocketwithLoveSBT 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 = "PocketwithLoveSBT";
    string private _baseUri =
        "https://nft-game.s3.ap-east-1.amazonaws.com/images";

    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

87742:14310:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61520:321;;;;;;;;;;-1:-1:-1;61520:321:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;61520:321:0;;;;;;;;97417:86;;;;;;;;;;-1:-1:-1;97483:12:0;;97417:86;;;738:25:1;;;726:2;711:18;97417:86:0;592:177:1;64756:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;66384:220::-;;;;;;;;;;-1:-1:-1;66384:220:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1896:32:1;;;1878:51;;1866:2;1851:18;66384:220:0;1732:203:1;65885:433:0;;;;;;;;;;-1:-1:-1;65885:433:0;;;;;:::i;:::-;;:::i;:::-;;99358:339;;;;;;;;;;-1:-1:-1;99358:339:0;;;;;:::i;:::-;;:::i;97610:446::-;;;;;;;;;;-1:-1:-1;97610:446:0;;;;;:::i;:::-;;:::i;93190:922::-;;;;;;:::i;:::-;;:::i;87827:33::-;;;;;;;;;;;;;;;;60760:312;;;;;;;;;;-1:-1:-1;61023:12:0;;60813:7;61007:13;:28;60760:312;;90326:434;;;;;;;;;;-1:-1:-1;90326:434:0;;;;;:::i;:::-;;:::i;67415:170::-;;;;;;;;;;-1:-1:-1;67415:170:0;;;;;:::i;:::-;;:::i;87867:33::-;;;;;;;;;;;;;;;;95050:633;;;;;;:::i;:::-;;:::i;91269:276::-;;;;;;;;;;-1:-1:-1;91269:276:0;;;;;:::i;:::-;;:::i;67656:185::-;;;;;;;;;;-1:-1:-1;67656:185:0;;;;;:::i;:::-;;:::i;96491:90::-;;;;;;;;;;-1:-1:-1;96491:90:0;;;;;:::i;:::-;;:::i;99025:166::-;;;;;;;;;;-1:-1:-1;99025:166:0;;;;;:::i;:::-;;:::i;90768:493::-;;;;;;;;;;-1:-1:-1;91066:13:0;;91105;;91147:16;;91193:17;;91238:15;;90768: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;90768:493:0;6531:463:1;91888:391:0;;;;;;;;;;-1:-1:-1;91888:391:0;;;;;:::i;:::-;;:::i;64564:125::-;;;;;;;;;;-1:-1:-1;64564:125:0;;;;;:::i;:::-;;:::i;83000:130::-;;;;;;;;;;-1:-1:-1;83000:130:0;;;;;:::i;:::-;;:::i;99199:151::-;;;;;;;;;;-1:-1:-1;99199:151:0;;;;;:::i;:::-;-1:-1:-1;;;;;99313:29:0;99286:7;99313:29;;;:12;:29;;;;;;;99199:151;88792:79;;;;;;;;;;-1:-1:-1;88792:79:0;;;;;:::i;:::-;;:::i;61905:206::-;;;;;;;;;;-1:-1:-1;61905:206:0;;;;;:::i;:::-;;:::i;33187:103::-;;;;;;;;;;;;;:::i;89547:228::-;;;;;;;;;;-1:-1:-1;89547:228:0;;;;;:::i;:::-;;:::i;89783:535::-;;;;;;;;;;-1:-1:-1;89783:535:0;;;;;:::i;:::-;;:::i;:::-;;;;9626:14:1;;9619:22;9601:41;;9685:14;;9678:22;9673:2;9658:18;;9651:50;9574:18;89783:535:0;9439:268:1;32546:87:0;;;;;;;;;;-1:-1:-1;32619:6:0;;-1:-1:-1;;;;;32619:6:0;32546:87;;89132:407;;;;;;;;;;-1:-1:-1;89391:13:0;;89430;;89472:16;;89516:15;;89132:407;;;9943:25:1;;;9999:2;9984:18;;9977:34;;;;10027:18;;;10020:34;10085:2;10070:18;;10063:34;9930:3;9915:19;89132:407:0;9712:391:1;81797:164:0;;;;;;;;;;-1:-1:-1;81797:164:0;;;;;:::i;:::-;;:::i;64925:104::-;;;;;;;;;;;;;:::i;83255:120::-;;;;;;;;;;-1:-1:-1;83255:120:0;;;;;:::i;:::-;;:::i;97099:100::-;;;;;;;;;;-1:-1:-1;97099:100:0;;;;;:::i;:::-;;:::i;66676:349::-;;;;;;;;;;-1:-1:-1;66676:349:0;;;;;:::i;:::-;;:::i;97511:91::-;;;;;;;;;;-1:-1:-1;97582:12:0;;97511:91;;91553:327;;;;;;;;;;-1:-1:-1;91775:13:0;;91814;;91856:16;;91553:327;;;11885:25:1;;;11941:2;11926:18;;11919:34;;;;11969:18;;;11962:34;11873:2;11858:18;91553:327:0;11683:319:1;92287:450:0;;;;;;;;;;-1:-1:-1;92557:12:0;;92675:13;;92287:450;;;92557:12;;;;12261:14:1;12254:22;12236:41;;92557:12:0;92594;;;;12320:14:1;12313:22;12308:2;12293:18;;12286:50;92634:15:0;;;;;12379:14:1;12372:22;12352:18;;;12345:50;;;;92675:13:0;;;12438:14:1;12431:22;12426:2;12411:18;;12404:50;92715:14:0;;;;;;;12498::1;12491:22;12485:3;12470:19;;12463:51;12223:3;12208:19;92287:450:0;12007:513:1;98730:122:0;;;;;;;;;;-1:-1:-1;98730:122:0;;;;;:::i;:::-;;:::i;67912:392::-;;;;;;;;;;-1:-1:-1;67912:392:0;;;;;:::i;:::-;;:::i;94120:922::-;;;;;;:::i;:::-;;:::i;97207:202::-;;;;;;;;;;-1:-1:-1;97207:202:0;;;;;:::i;:::-;;:::i;95691:792::-;;;;;;;;;;-1:-1:-1;95691:792:0;;;;;:::i;:::-;;:::i;98860:100::-;;;;;;;;;;-1:-1:-1;98937:15:0;;98860:100;;67096:189;;;;;;;;;;-1:-1:-1;67096:189:0;;;;;:::i;:::-;-1:-1:-1;;;;;67242:25:0;;;67218:4;67242:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;67096:189;96589:139;;;;;;;;;;-1:-1:-1;96589:139:0;;;;;:::i;:::-;;:::i;99705:2344::-;;;;;;:::i;:::-;;:::i;33445:238::-;;;;;;;;;;-1:-1:-1;33445:238:0;;;;;:::i;:::-;;:::i;81722:66::-;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;81722:66:0;;83383:124;;;;;;;;;;-1:-1:-1;83383:124:0;;;;;:::i;:::-;;:::i;61520:321::-;61638:4;-1:-1:-1;;;;;;61675:40:0;;-1:-1:-1;;;61675:40:0;;:105;;-1:-1:-1;;;;;;;61732:48:0;;-1:-1:-1;;;61732:48:0;61675:105;:158;;;-1:-1:-1;;;;;;;;;;58701:40:0;;;61797:36;61655:178;61520:321;-1:-1:-1;;61520:321:0:o;64756:100::-;64810:13;64843:5;64836:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64756:100;:::o;66384:220::-;66468:7;66493:16;66501:7;66493;:16::i;:::-;66488:64;;66518:34;;-1:-1:-1;;;66518:34:0;;;;;;;;;;;66488:64;-1:-1:-1;66572:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;66572:24:0;;66384:220::o;65885:433::-;65966:18;65981:2;65966:14;:18::i;:::-;65997:13;66013:24;66029:7;66013:15;:24::i;:::-;65997:40;;66058:5;-1:-1:-1;;;;;66052:11:0;:2;-1:-1:-1;;;;;66052:11:0;;66048:48;;66072:24;;-1:-1:-1;;;66072:24:0;;;;;;;;;;;66048:48;13718:10;-1:-1:-1;;;;;66113:21:0;;;66109:161;;66154:37;66171:5;13718:10;67096:189;:::i;66154:37::-;66149:121;;66219:35;;-1:-1:-1;;;66219:35:0;;;;;;;;;;;66149:121;66282:28;66291:2;66295:7;66304:5;66282:8;:28::i;:::-;65955:363;65885:433;;:::o;99358:339::-;-1:-1:-1;;;;;99500:29:0;;99476:7;99500:29;;;:12;:29;;;;;;:34;;99496:75;;-1:-1:-1;99558:1:0;99551:8;;99496:75;-1:-1:-1;;;;;99646:34:0;;;;;;:17;:34;;;;;;;:43;;;;;;;;;99601:29;;;:12;:29;;;;;;:88;;99646:43;99601:88;:::i;:::-;99581:108;99358:339;-1:-1:-1;;;99358:339:0:o;97610:446::-;82875:24;13718:10;83000:130;:::i;82875:24::-;82853:119;;;;-1:-1:-1;;;82853:119:0;;;;;;;:::i;:::-;;;;;;;;;97727:7:::1;97722:236;97740:6;:13;97736:1;:17;;;97722:236;;;97775:12;97797:6;97804:1;97797:9;;;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;97834:30:::1;::::0;-1:-1:-1;;;97834:30:0;;97858:4:::1;97834:30;::::0;::::1;1878:51:1::0;97797:9:0;;-1:-1:-1;97822:9:0::1;::::0;-1:-1:-1;;;;;97834:15:0;::::1;::::0;::::1;::::0;1851:18:1;;97834:30:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;97822:42:::0;-1:-1:-1;97883:5:0;;97879:68:::1;;97909:22;::::0;-1:-1:-1;;;97909:22:0;;-1:-1:-1;;;;;17385:32:1;;;97909:22:0::1;::::0;::::1;17367:51:1::0;17434:18;;;17427:34;;;97909:14:0;::::1;::::0;::::1;::::0;17340:18:1;;97909:22:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;97879:68;97760:198;;97755:3;;;;;:::i;:::-;;;;97722:236;;;-1:-1:-1::0;98018:30:0::1;::::0;97986:21:::1;::::0;-1:-1:-1;;;;;98018:21:0;::::1;::::0;:30;::::1;;;::::0;97986:21;;97968:15:::1;98018:30:::0;97968:15;98018:30;97986:21;98018;:30;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;97711:345;97610:446:::0;;:::o;93190:922::-;12149:21;:19;:21::i;:::-;93335:1:::1;93326:5;:10;;93318:57;;;;-1:-1:-1::0;;;93318:57:0::1;;;;;;;:::i;:::-;93439:5;93423:13;;:21;;;;:::i;:::-;93410:9;:34;93388:118;;;;-1:-1:-1::0;;;93388:118:0::1;;;;;;;:::i;:::-;93527:12;::::0;::::1;;93519:47;;;;-1:-1:-1::0;;;93519:47:0::1;;;;;;;:::i;:::-;93601:158;93638:11;;93601:158;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;93668:18:0::1;::::0;93715:28:::1;::::0;93668:18;;-1:-1:-1;93715:28:0::1;::::0;-1:-1:-1;93732:10:0::1;::::0;93715:28:::1;;;:::i;:::-;;;;;;;;;;;;;93705:39;;;;;;93601:18;:158::i;:::-;93579:240;;;::::0;-1:-1:-1;;;93579:240:0;;19668:2:1;93579:240:0::1;::::0;::::1;19650:21:1::0;;;19687:18;;;19680:30;19746:34;19726:18;;;19719:62;19798:18;;93579:240:0::1;19466:356:1::0;93579:240:0::1;93837:9;93832:273;93856:5;93852:1;:9;93832:273;;;93925:13;;93909;;:29;93883:118;;;;-1:-1:-1::0;;;93883:118:0::1;;;;;;;:::i;:::-;94018:25;13718:10:::0;94018:11:::1;:25::i;:::-;94076:13;::::0;:17:::1;::::0;94092:1:::1;94076:17;:::i;:::-;94060:13;:33:::0;93863:3;::::1;::::0;::::1;:::i;:::-;;;;93832:273;;;;12193:20:::0;11587:1;12713:7;:22;12530:213;90326:434;82875:24;13718:10;83000:130;:::i;82875:24::-;82853:119;;;;-1:-1:-1;;;82853:119:0;;;;;;;:::i;:::-;90550:13:::1;:28:::0;;;;90589:13:::1;:28:::0;;;;90628:16:::1;:34:::0;90673:17:::1;:36:::0;90720:15:::1;:32:::0;90326:434::o;67415:170::-;67549:28;67559:4;67565:2;67569:7;67549:9;:28::i;95050:633::-;12149:21;:19;:21::i;:::-;95141:1:::1;95132:5;:10;;95124:57;;;;-1:-1:-1::0;;;95124:57:0::1;;;;;;;:::i;:::-;95248:5;95229:16;;:24;;;;:::i;:::-;95216:9;:37;95194:121;;;;-1:-1:-1::0;;;95194:121:0::1;;;;;;;:::i;:::-;95336:15;::::0;;;::::1;;;95328:50;;;;-1:-1:-1::0;;;95328:50:0::1;;;;;;;:::i;:::-;95396:9;95391:285;95415:5;95411:1;:9;95391:285;;;95487:16;;95468;;:35;95442:124;;;;-1:-1:-1::0;;;95442:124:0::1;;;;;;;:::i;:::-;95583:25;13718:10:::0;94018:11:::1;:25::i;95583:::-;95644:16;::::0;:20:::1;::::0;95663:1:::1;95644:20;:::i;:::-;95625:16;:39:::0;95422:3;::::1;::::0;::::1;:::i;:::-;;;;95391:285;;;;12193:20:::0;11587:1;12713:7;:22;12530:213;12193:20;95050:633;:::o;91269:276::-;82875:24;13718:10;83000:130;:::i;82875:24::-;82853:119;;;;-1:-1:-1;;;82853:119:0;;;;;;;:::i;:::-;91425:13:::1;:28:::0;;;;91464:13:::1;:28:::0;91503:16:::1;:34:::0;91269:276::o;67656:185::-;67794:39;67811:4;67817:2;67821:7;67794:39;;;;;;;;;;;;:16;:39::i;96491:90::-;82875:24;13718:10;83000:130;:::i;82875:24::-;82853:119;;;;-1:-1:-1;;;82853:119:0;;;;;;;:::i;:::-;96553:20:::1;96565:7;96553:11;:20::i;99025:166::-:0;82875:24;13718:10;83000:130;:::i;82875:24::-;82853:119;;;;-1:-1:-1;;;82853:119:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;99146:29:0;;::::1;;::::0;;;:12:::1;:29;::::0;;;;:37;99025:166::o;91888:391::-;82875:24;13718:10;83000:130;:::i;82875:24::-;82853:119;;;;-1:-1:-1;;;82853:119:0;;;;;;;:::i;:::-;92085:12:::1;:26:::0;;92202:13:::1;:28:::0;;-1:-1:-1;;92202:28:0::1;::::0;::::1;;::::0;;;::::1;::::0;;;-1:-1:-1;;92122:26:0;;;92085;::::1;;-1:-1:-1::0;;92122:26:0;;;;;92085::::1;92122::::0;::::1;;::::0;;;::::1;::::0;;;::::1;-1:-1:-1::0;;92241:30:0;92159:32;;::::1;;::::0;;;::::1;-1:-1:-1::0;;92241:30:0;;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;91888:391::o;64564:125::-;64628:7;64655:21;64668:7;64655:12;:21::i;:::-;:26;;64564:125;-1:-1:-1;;64564:125:0:o;83000:130::-;83067:4;83091:31;-1:-1:-1;;;;;;;;;;;83114:7:0;83091;:31::i;88792:79::-;82875:24;13718:10;83000:130;:::i;82875:24::-;82853:119;;;;-1:-1:-1;;;82853:119:0;;;;;;;:::i;:::-;88851:5:::1;:12:::0;;;::::1;;;;-1:-1:-1::0;;88851:12:0;;::::1;::::0;;;::::1;::::0;;88792:79::o;61905:206::-;61969:7;-1:-1:-1;;;;;61993:19:0;;61989:60;;62021:28;;-1:-1:-1;;;62021:28:0;;;;;;;;;;;61989:60;-1:-1:-1;;;;;;62075:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;62075:27:0;;61905:206::o;33187:103::-;32432:13;:11;:13::i;:::-;33252:30:::1;33279:1;33252:18;:30::i;:::-;33187:103::o:0;89547:228::-;82875:24;13718:10;83000:130;:::i;82875:24::-;82853:119;;;;-1:-1:-1;;;82853:119:0;;;;;;;:::i;:::-;89680:18:::1;:38:::0;;;;89729:18:::1;:38:::0;89547:228::o;89783:535::-;89920:19;89941;89990:145;90023:14;;89990:145;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;90052:18:0;;90095:28;;90052:18;;-1:-1:-1;90095:28:0;;-1:-1:-1;90112:10:0;;90095:28;;;:::i;89990:145::-;89973:162;;90165:145;90198:14;;90165:145;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;90227:18:0;;90270:28;;90227:18;;-1:-1:-1;90270:28:0;;-1:-1:-1;90287:10:0;;90270:28;;;:::i;90165:145::-;90148:162;;89783:535;;;;;;;:::o;81797:164::-;81900:4;81924:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;81924:29:0;;;;;;;;;;;;;;;81797:164::o;64925:104::-;64981:13;65014:7;65007:14;;;;;:::i;83255:120::-;82875:24;13718:10;83000:130;:::i;82875:24::-;82853:119;;;;-1:-1:-1;;;82853:119:0;;;;;;;:::i;:::-;83333:34:::1;-1:-1:-1::0;;;;;;;;;;;83359:7:0::1;83333:10;:34::i;97099:100::-:0;82875:24;13718:10;83000:130;:::i;82875:24::-;82853:119;;;;-1:-1:-1;;;82853:119:0;;;;;;;:::i;:::-;97173:18;;::::1;::::0;:8:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;:::-;;97099:100:::0;:::o;66676:349::-;66796:24;66811:8;66796:14;:24::i;:::-;13718:10;-1:-1:-1;;;;;66837:24:0;;;66833:54;;66870:17;;-1:-1:-1;;;66870:17:0;;;;;;;;;;;66833:54;13718:10;66900:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;66900:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;66900:53:0;;;;;;;;;;66969:48;;540:41:1;;;66900:42:0;;13718:10;66969:48;;513:18:1;66969:48:0;;;;;;;66676:349;;:::o;98730:122::-;82875:24;13718:10;83000:130;:::i;82875:24::-;82853:119;;;;-1:-1:-1;;;82853:119:0;;;;;;;:::i;:::-;98812:15:::1;:32:::0;98730:122::o;67912:392::-;68079:28;68089:4;68095:2;68099:7;68079:9;:28::i;:::-;-1:-1:-1;;;;;68122:13:0;;35725:19;:23;68118:179;;68157:56;68188:4;68194:2;68198:7;68207:5;68157:30;:56::i;:::-;68152:145;;68241:40;;-1:-1:-1;;;68241:40:0;;;;;;;;;;;94120:922;12149:21;:19;:21::i;:::-;94265:1:::1;94256:5;:10;;94248:57;;;;-1:-1:-1::0;;;94248:57:0::1;;;;;;;:::i;:::-;94369:5;94353:13;;:21;;;;:::i;:::-;94340:9;:34;94318:118;;;;-1:-1:-1::0;;;94318:118:0::1;;;;;;;:::i;:::-;94457:12;::::0;::::1;::::0;::::1;;;94449:47;;;;-1:-1:-1::0;;;94449:47:0::1;;;;;;;:::i;:::-;94531:158;94568:11;;94531:158;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;94598:18:0::1;::::0;94645:28:::1;::::0;94598:18;;-1:-1:-1;94645:28:0::1;::::0;-1:-1:-1;94662:10:0::1;::::0;94645:28:::1;;;:::i;94531:158::-;94509:240;;;::::0;-1:-1:-1;;;94509:240:0;;19668:2:1;94509:240:0::1;::::0;::::1;19650:21:1::0;;;19687:18;;;19680:30;19746:34;19726:18;;;19719:62;19798:18;;94509:240:0::1;19466:356:1::0;94509:240:0::1;94767:9;94762:273;94786:5;94782:1;:9;94762:273;;;94855:13;;94839;;:29;94813:118;;;;-1:-1:-1::0;;;94813:118:0::1;;;;;;;:::i;:::-;94948:25;13718:10:::0;94018:11:::1;:25::i;94948:::-;95006:13;::::0;:17:::1;::::0;95022:1:::1;95006:17;:::i;:::-;94990:13;:33:::0;94793:3;::::1;::::0;::::1;:::i;:::-;;;;94762:273;;97207:202:::0;97288:13;97358:8;97373:17;97382:7;97373:8;:17::i;:::-;97341:59;;;;;;;;;:::i;:::-;;;;;;;;;;;;;97314:87;;97207:202;;;:::o;95691:792::-;82875:24;13718:10;83000:130;:::i;82875:24::-;82853:119;;;;-1:-1:-1;;;82853:119:0;;;;;;;:::i;:::-;95869:7:::1;:14;95847:11;:18;:36;95825:146;;;::::0;-1:-1:-1;;;95825:146:0;;22649:2:1;95825: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;;95825:146:0::1;22447:424:1::0;95825:146:0::1;95999:18:::0;;95984:12:::1;96028:448;96050:4;96045:2;:9;96028:448;;;96077:10;96090:11;96102:2;96090:15;;;;;;;;:::i;:::-;;;;;;;96077:28;;96120:14;96137:7;96145:2;96137:11;;;;;;;;:::i;:::-;;;;;;;96120:28;;96170:9;96165:300;96189:6;96185:1;:10;96165:300;;;96266:12;;96251;;:27;96221:139;;;;-1:-1:-1::0;;;96221:139:0::1;;;;;;;:::i;:::-;96381:16;96391:2;96395:1;96381:9;:16::i;:::-;96433:12;::::0;:16:::1;::::0;96448:1:::1;96433:16;:::i;:::-;96418:12;:31:::0;96197:3;::::1;::::0;::::1;:::i;:::-;;;;96165:300;;;;96062:414;;96056:4;;;;;:::i;:::-;;;;96028:448;;96589:139:::0;-1:-1:-1;;;;;96698:22:0;;96651:7;96698:22;;;:16;:22;;;;;;96678:17;;:42;;96698:22;96678:42;:::i;99705:2344::-;12149:21;:19;:21::i;:::-;99919:8:::1;:15;99899:9;:16;:35;99877:145;;;::::0;-1:-1:-1;;;99877:145:0;;23485:2:1;99877: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;;99877:145:0::1;23283:424:1::0;99877:145:0::1;100076:6;:13;100057:8;:15;:32;100035:139;;;::::0;-1:-1:-1;;;100035:139:0;;23914:2:1;100035: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;;100035:139:0::1;23712:421:1::0;100035:139:0::1;100195:14;::::0;;;::::1;;;100187:49;;;::::0;-1:-1:-1;;;100187:49:0;;24340:2:1;100187: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;;100187:49:0::1;24138:346:1::0;100187:49:0::1;100249:22;100291:9:::0;100286:116:::1;100310:8;:15;100306:1;:19;100286:116;;;100381:6;100388:1;100381:9;;;;;;;;:::i;:::-;;;;;;;100364:14;:26;;;;:::i;:::-;100347:43:::0;-1:-1:-1;100327:3:0;::::1;::::0;::::1;:::i;:::-;;;;100286:116;;;;100439:2;100422:14;:19;100414:53;;;::::0;-1:-1:-1;;;100414:53:0;;24691:2:1;100414: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;;100414:53:0::1;24489:345:1::0;100414:53:0::1;100533:14;100515:15;;:32;;;;:::i;:::-;100502:9;:45;100480:129;;;::::0;-1:-1:-1;;;100480:129:0;;25041:2:1;100480: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;;100480:129:0::1;24839:398:1::0;100480:129:0::1;100627:9;100622:1420;100646:8;:15;100642:1;:19;100622:1420;;;100683:23;100709:9;100719:1;100709:12;;;;;;;;:::i;:::-;;;;;;;100683:38;;100736:15;100754:8;100763:1;100754:11;;;;;;;;:::i;:::-;;;;;;;100736:29;;100780:17;100800:6;100807:1;100800:9;;;;;;;;:::i;:::-;;;;;;;100780:29;;100897:10;-1:-1:-1::0;;;;;100852:55:0::1;100860:15;-1:-1:-1::0;;;;;100852:32:0::1;;100885:7;100852:41;;;;;;;;;;;;;738:25:1::0;;726:2;711:18;;592:177;100852:41:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;100852:55:0::1;;100826:137;;;::::0;-1:-1:-1;;;100826:137:0;;25700:2:1;100826: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;;100826:137:0::1;25498:344:1::0;100826:137:0::1;-1:-1:-1::0;;;;;101006:29:0;::::1;101038:1;101006:29:::0;;;:12:::1;:29;::::0;;;;;100980:127:::1;;;::::0;-1:-1:-1;;;100980:127:0;;26049:2:1;100980:127:0::1;::::0;::::1;26031:21:1::0;;;26068:18;;;26061:30;26127:34;26107:18;;;26100:62;26179:18;;100980:127:0::1;25847:356:1::0;100980:127:0::1;-1:-1:-1::0;;;;;101230:29:0;::::1;;::::0;;;:12:::1;:29;::::0;;;;;;;;101150:34;;;;;;:43;;;;;;;;;;:55:::1;::::0;101196:9;;101150:55:::1;:::i;:::-;:109;;101124:212;;;::::0;-1:-1:-1;;;101124:212:0;;26410:2:1;101124: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;;101124:212:0::1;26208:405:1::0;101124:212:0::1;101407:12;;101394:9;101379:12;;:24;;;;:::i;:::-;:40;;101353:140;;;::::0;-1:-1:-1;;;101353:140:0;;26820:2:1;101353: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;;101353:140:0::1;26618:402:1::0;101353:140:0::1;101567:15;;101554:9;101536:15;;:27;;;;:::i;:::-;:46;;101510:135;;;::::0;-1:-1:-1;;;101510:135:0;;27227:2:1;101510:135:0::1;::::0;::::1;27209:21:1::0;27266:2;27246:18;;;27239:30;27305:29;27285:18;;;27278:57;27352:18;;101510:135:0::1;27025:351:1::0;101510:135:0::1;101667:9;101662:99;101686:9;101682:1;:13;101662:99;;;101721:24;101731:10;101743:1;101721:9;:24::i;:::-;101697:3:::0;::::1;::::0;::::1;:::i;:::-;;;;101662:99;;;;101813:9;101795:15;;:27;;;;:::i;:::-;101777:15;:45:::0;101854:12:::1;::::0;:24:::1;::::0;101869:9;;101854:24:::1;:::i;:::-;101839:12;:39:::0;-1:-1:-1;;;;;101958:34:0;::::1;;::::0;;;:17:::1;:34:::0;;;;;;;:43;;;;;;;;;:72:::1;::::0;102021:9;;101958:72:::1;:::i;:::-;-1:-1:-1::0;;;;;101895:34:0;;::::1;;::::0;;;:17:::1;:34:::0;;;;;;;:43;;;;;;;;;;:135;;;;-1:-1:-1;100663:3:0;::::1;::::0;::::1;:::i;:::-;;;;100622:1420;;;;99866:2183;12193:20:::0;11587:1;12713:7;:22;12530:213;33445:238;32432:13;:11;:13::i;:::-;-1:-1:-1;;;;;33548:22:0;::::1;33526:110;;;::::0;-1:-1:-1;;;33526:110:0;;27583:2:1;33526: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;;33526:110:0::1;27381:402:1::0;33526:110:0::1;33647:28;33666:8;33647:18;:28::i;83383:124::-:0;82875:24;13718:10;83000:130;:::i;82875:24::-;82853:119;;;;-1:-1:-1;;;82853:119:0;;;;;;;:::i;:::-;83464:35:::1;-1:-1:-1::0;;;;;;;;;;;83491:7:0::1;83464:11;:35::i;68559:213::-:0;68616:4;68706:13;;68696:7;:23;68653:111;;;;-1:-1:-1;;68737:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;68737:27:0;;;;68736:28;;68559:213::o;96970:121::-;97048:5;;;;;;;97040:43;;;;-1:-1:-1;;;97040:43:0;;27990:2:1;97040:43:0;;;27972:21:1;28029:2;28009:18;;;28002:30;28068:27;28048:18;;;28041:55;28113:18;;97040:43:0;27788:349:1;77839:162:0;77920:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;77920:29:0;-1:-1:-1;;;;;77920:29:0;;;;;;;;;77965:28;;77920:24;;77965:28;;;;;;;77839:162;;;:::o;12229:293::-;11631:1;12363:7;;:19;12355:63;;;;-1:-1:-1;;;12355:63:0;;28344:2:1;12355:63:0;;;28326:21:1;28383:2;28363:18;;;28356:30;28422:33;28402:18;;;28395:61;28473:18;;12355:63:0;28142:355:1;12355:63:0;11631:1;12496:7;:18;12229: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;92745:437::-;92843:17;;-1:-1:-1;;;;;92820:20:0;;;;;;:16;:20;;;;;;:40;92798:117;;;;-1:-1:-1;;;92798:117:0;;28704:2:1;92798:117:0;;;28686:21:1;28743:2;28723:18;;;28716:30;28782:29;28762:18;;;28755:57;28829:18;;92798:117:0;28502:351:1;92798:117:0;92963:12;;92948;;:27;92926:115;;;;-1:-1:-1;;;92926:115:0;;;;;;;:::i;:::-;93054:16;93064:2;93068:1;93054:9;:16::i;:::-;-1:-1:-1;;;;;93106:20:0;;;;;;:16;:20;;;;;;:24;;93129:1;93106:24;:::i;:::-;-1:-1:-1;;;;;93083:20:0;;;;;;:16;:20;;;;;:47;93158:12;;:16;;93173:1;93158:16;:::i;:::-;93143:12;:31;-1:-1:-1;92745:437:0:o;72885:2096::-;72966:35;73004:21;73017:7;73004:12;:21::i;:::-;72966:59;;73064:4;-1:-1:-1;;;;;73042:26:0;:13;:18;;;-1:-1:-1;;;;;73042:26:0;;73038:67;;73077:28;;-1:-1:-1;;;73077:28:0;;;;;;;;;;;73038:67;73118:22;13718:10;-1:-1:-1;;;;;73144:20:0;;;;:73;;-1:-1:-1;73181:36:0;73198:4;13718:10;67096:189;:::i;73181:36::-;73144:126;;;-1:-1:-1;13718:10:0;73234:20;73246:7;73234:11;:20::i;:::-;-1:-1:-1;;;;;73234:36:0;;73144:126;73118:153;;73289:17;73284:66;;73315:35;;-1:-1:-1;;;73315:35:0;;;;;;;;;;;73284:66;-1:-1:-1;;;;;73365:16:0;;73361:52;;73390:23;;-1:-1:-1;;;73390:23:0;;;;;;;;;;;73361:52;73426:43;73448:4;73454:2;73458:7;73467:1;73426:21;:43::i;:::-;73534:35;73551:1;73555:7;73564:4;73534:8;:35::i;:::-;-1:-1:-1;;;;;73865:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;73865:31:0;;;-1:-1:-1;;;;;73865:31:0;;;-1:-1:-1;;73865:31:0;;;;;;;73911:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;73911:29:0;;;;;;;;;;;73991:20;;;:11;:20;;;;;;74026:18;;-1:-1:-1;;;;;;74059:49:0;;;;-1:-1:-1;;;74092:15:0;74059:49;;;;;;;;;;74382:11;;74442:24;;;;;74485:13;;73991:20;;74442:24;;74485:13;74481:384;;74695:13;;74680:11;:28;74676:174;;74733:20;;74802:28;;;;-1:-1:-1;;;;;74776:54:0;-1:-1:-1;;;74776:54:0;-1:-1:-1;;;;;;74776:54:0;;;-1:-1:-1;;;;;74733:20:0;;74776:54;;;;74676:174;73840:1036;;;74912:7;74908:2;-1:-1:-1;;;;;74893:27:0;74902:4;-1:-1:-1;;;;;74893:27:0;-1:-1:-1;;;;;;;;;;;74893:27:0;;;;;;;;;72955:2026;;72885:2096;;;:::o;75059:89::-;75119:21;75125:7;75134:5;75119;:21::i;63286:1216::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;63413:7:0;63515:13;;63508:4;:20;63504:931;;;63553:31;63587:17;;;:11;:17;;;;;;;;;63553:51;;;;;;;;;-1:-1:-1;;;;;63553:51:0;;;;-1:-1:-1;;;63553:51:0;;-1:-1:-1;;;;;63553:51:0;;;;;;;;-1:-1:-1;;;63553:51:0;;;;;;;;;;;;;;63627:789;;63681:14;;-1:-1:-1;;;;;63681:28:0;;63677:109;;63749:9;63286:1216;-1:-1:-1;;;63286:1216:0:o;63677:109::-;-1:-1:-1;;;64152:6:0;64201:17;;;;:11;:17;;;;;;;;;64189:29;;;;;;;;;-1:-1:-1;;;;;64189:29:0;;;;;-1:-1:-1;;;64189:29:0;;-1:-1:-1;;;;;64189:29:0;;;;;;;;-1:-1:-1;;;64189:29:0;;;;;;;;;;;;;64253:28;64249:117;;64325:9;63286:1216;-1:-1:-1;;;63286:1216:0:o;64249:117::-;64108:285;;;63530:905;63504:931;64463:31;;-1:-1:-1;;;64463:31:0;;;;;;;;;;;32711:132;32619:6;;-1:-1:-1;;;;;32619:6:0;13718:10;32775:23;32767:68;;;;-1:-1:-1;;;32767:68:0;;29060:2:1;32767:68:0;;;29042:21:1;;;29079:18;;;29072:30;29138:34;29118:18;;;29111:62;29190:18;;32767:68:0;28858:356:1;33843:191:0;33936:6;;;-1:-1:-1;;;;;33953:17:0;;;-1:-1:-1;;;;;;33953:17:0;;;;;;;33986:40;;33936:6;;;33953:17;33936:6;;33986:40;;33917:16;;33986:40;33906:128;33843:191;:::o;81969:229::-;82044:22;82052:4;82058:7;82044;:22::i;:::-;82039:152;;82083:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;82083:29:0;;;;;;;;;:36;;-1:-1:-1;;82083:36:0;82115:4;82083:36;;;82166:12;13718:10;;13638:98;82166:12;-1:-1:-1;;;;;82139:40:0;82157:7;-1:-1:-1;;;;;82139:40:0;82151:4;82139:40;;;;;;;;;;81969:229;;:::o;78493:772::-;78690:155;;-1:-1:-1;;;78690:155:0;;78656:4;;-1:-1:-1;;;;;78690:36:0;;;;;:155;;13718:10;;78776:4;;78799:7;;78825:5;;78690:155;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;78690:155:0;;;;;;;;-1:-1:-1;;78690:155:0;;;;;;;;;;;;:::i;:::-;;;78673:585;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79016:6;:13;79033:1;79016:18;79012:235;;79062:40;;-1:-1:-1;;;79062:40:0;;;;;;;;;;;79012:235;79205:6;79199:13;79190:6;79186:2;79182:15;79175:38;78673:585;-1:-1:-1;;;;;;78901:55:0;-1:-1:-1;;;78901:55:0;;-1:-1:-1;78673:585:0;78493:772;;;;;;:::o;98064:532::-;98120:13;98150:5;98159:1;98150:10;98146:53;;-1:-1:-1;;98177:10:0;;;;;;;;;;;;-1:-1:-1;;;98177:10:0;;;;;98064:532::o;98146:53::-;98224:5;98209:12;98265:78;98272:9;;98265:78;;98298:8;;;;:::i;:::-;;-1:-1:-1;98321:10:0;;-1:-1:-1;98329:2:0;98321:10;;:::i;:::-;;;98265:78;;;98353:19;98385:6;-1:-1:-1;;;;;98375:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;98375:17:0;;98353:39;;98403:154;98410:10;;98403:154;;98437:11;98447:1;98437:11;;:::i;:::-;;-1:-1:-1;98506:10:0;98514:2;98506:5;:10;:::i;:::-;98493:24;;:2;:24;:::i;:::-;98480:39;;98463:6;98470;98463:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;98463:56:0;;;;;;;;-1:-1:-1;98534:11:0;98543:2;98534:11;;:::i;:::-;;;98403:154;;68856:104;68925:27;68935:2;68939:8;68925:27;;;;;;;;;;;;:9;:27::i;82326:230::-;82401:22;82409:4;82415:7;82401;:22::i;:::-;82397:152;;;82472:5;82440:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;82440:29:0;;;;;;;;;;:37;;-1:-1:-1;;82440:37:0;;;82497:40;13718:10;;82440:12;;82497:40;;82472:5;82497:40;82326: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;96736:226::-;96918:5;;;;;;;96910:44;;;;-1:-1:-1;;;96910:44:0;;30554:2:1;96910:44:0;;;30536:21:1;30593:2;30573:18;;;30566:30;30632:28;30612:18;;;30605:56;30678:18;;96910:44:0;30352:350:1;75377:2344:0;75457:35;75495:21;75508:7;75495:12;:21::i;:::-;75544:18;;75457:59;;-1:-1:-1;75575:290:0;;;;75609:22;13718:10;-1:-1:-1;;;;;75635:20:0;;;;:77;;-1:-1:-1;75676:36:0;75693:4;13718:10;67096:189;:::i;75676:36::-;75635:134;;;-1:-1:-1;13718:10:0;75733:20;75745:7;75733:11;:20::i;:::-;-1:-1:-1;;;;;75733:36:0;;75635:134;75609:161;;75792:17;75787:66;;75818:35;;-1:-1:-1;;;75818:35:0;;;;;;;;;;;75787:66;75594:271;75575:290;75929:35;75946:1;75950:7;75959:4;75929:8;:35::i;:::-;-1:-1:-1;;;;;76294:18:0;;;76260:31;76294:18;;;:12;:18;;;;;;;;76327:24;;-1:-1:-1;;;;;;;;;;76327:24:0;;;;;;;;;-1:-1:-1;;76327:24:0;;;;76366:29;;;;;76350:1;76366:29;;;;;;;;-1:-1:-1;;76366:29:0;;;;;;;;;;76528:20;;;:11;:20;;;;;;76563;;-1:-1:-1;;;;76631:15:0;76598:49;;;-1:-1:-1;;;76598:49:0;-1:-1:-1;;;;;;76598:49:0;;;;;;;;;;76662:22;-1:-1:-1;;;76662:22:0;;;76954:11;;;77014:24;;;;;77057:13;;76294:18;;77014:24;;77057:13;77053:384;;77267:13;;77252:11;:28;77248:174;;77305:20;;77374:28;;;;-1:-1:-1;;;;;77348:54:0;-1:-1:-1;;;77348:54:0;-1:-1:-1;;;;;;77348:54:0;;;-1:-1:-1;;;;;77305:20:0;;77348:54;;;;77248:174;-1:-1:-1;;77465:35:0;;77492:7;;-1:-1:-1;77488:1:0;;-1:-1:-1;;;;;;77465:35:0;;;-1:-1:-1;;;;;;;;;;;77465:35:0;77488:1;;77465:35;-1:-1:-1;;77688:12:0;:14;;;;;;-1:-1:-1;;75377:2344:0:o;69333:1866::-;69456:20;69479:13;-1:-1:-1;;;;;69507:16:0;;69503:48;;69532:19;;-1:-1:-1;;;69532:19:0;;;;;;;;;;;69503:48;69566:8;69578:1;69566:13;69562:44;;69588:18;;-1:-1:-1;;;69588:18:0;;;;;;;;;;;69562:44;-1:-1:-1;;;;;69883:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;69942:49:0;;-1:-1:-1;;;;;69883:44:0;;;;;;;69942:49;;;;-1:-1:-1;;69883:44:0;;;;;;69942:49;;;;;;;;;;;;;;;;70008:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;70058:66:0;;;-1:-1:-1;;;70108:15:0;70058:66;;;;;;;;;;;;;70008:25;;70205:23;;;;35725:19;:23;70245:822;;70285:504;70316:38;;70341:12;;-1:-1:-1;;;;;70316:38:0;;;70333:1;;-1:-1:-1;;;;;;;;;;;70316:38:0;70333:1;;70316:38;70408:212;70477:1;70510:2;70543:14;;;;;;70588:5;70408:30;:212::i;:::-;70377:365;;70678:40;;-1:-1:-1;;;70678:40:0;;;;;;;;;;;70377:365;70784:3;70769:12;:18;70285:504;;70870:12;70853:13;;:29;70849:43;;70884:8;;;70849:43;70245:822;;;70933:119;70964:40;;70989:14;;;;;-1:-1:-1;;;;;70964:40:0;;;70981:1;;-1:-1:-1;;;;;;;;;;;70964:40:0;70981:1;;70964:40;71047:3;71032:12;:18;70933:119;;70245:822;-1:-1:-1;71081:13:0;:28;;;71131:60;;71164:2;71168:12;71182:8;71131:60;:::i;9443:149::-;9506:7;9537:1;9533;:5;:51;;9693:13;9787:15;;;9823:4;9816:15;;;9870:4;9854:21;;9533:51;;;9693:13;9787:15;;;9823:4;9816:15;;;9870:4;9854:21;;9541:20;9600: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://67c4a6ce1356b7cce396eca2943dc6db569cc4d314e928c446907ae69c3ecfb6

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