Token

Vindico Studios - TKTV Presale Mint Pass (TKTV Presale Mint Pass)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-721

Overview

Max Total Supply

354 TKTV Presale Mint Pass

Holders

303

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x512bb4934312af5173230b569b963095085b31fd

Filtered by Token Holder

0x85495cc16306430Fe978C9EdD298c762aCBA3d28

Balance

1 TKTV Presale Mint Pass

0x85495cc16306430fe978c9edd298c762acba3d28

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

TKTVPresaleMintPass

Compiler Version

v0.8.20+commit.a1b79de6

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-07-03
*/

// File: @openzeppelin/contracts/utils/cryptography/MerkleProof.sol


// OpenZeppelin Contracts (last updated v4.9.2) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

        if (totalHashes > 0) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

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

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

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

        if (totalHashes > 0) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

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

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

// File: @openzeppelin/contracts/utils/math/SignedMath.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // 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);
        }
    }
}

// File: @openzeppelin/contracts/utils/Strings.sol


// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)

pragma solidity ^0.8.0;



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

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

    /**
     * @dev Converts a `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));
    }
}

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. 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);
    }
}

// File: @openzeppelin/contracts/utils/Address.sol


// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

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

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;


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

// File: utils/ERC721A.sol


// Creator: Chiru Labs
pragma solidity ^0.8.4;









error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error BurnedQueryForZeroAddress();
error AuxQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();

/**
 * @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, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

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

    // 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 See {IERC721Enumerable-totalSupply}.
     * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
     */
    function totalSupply() public view 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) {
        if (owner == address(0)) revert MintedQueryForZeroAddress();
        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) {
        if (owner == address(0)) revert BurnedQueryForZeroAddress();
        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) {
        if (owner == address(0)) revert AuxQueryForZeroAddress();
        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 {
        if (owner == address(0)) revert AuxQueryForZeroAddress();
        _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 && curr < _currentIndex) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (!ownership.burned) {
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                    // Invariant:
                    // There will always be an ownership that has an address and is not burned
                    // before an ownership that does not have an address and is not burned.
                    // Hence, curr will not underflow.
                    while (true) {
                        curr--;
                        ownership = _ownerships[curr];
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                    }
                }
            }
        }
        revert OwnerQueryForNonexistentToken();
    }

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

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

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

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

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

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

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

        if (_msgSender() != owner && !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 override {
        if (operator == _msgSender()) revert ApproveToCaller();

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

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

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

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (to.isContract() && !_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;
    }

    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 {
        _mint(to, quantity, _data, true);
    }

    /**
     * @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,
        bytes memory _data,
        bool safe
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

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

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

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

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

            if (safe && 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 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);

        bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
            isApprovedForAll(prevOwnership.addr, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

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

        // 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;

            _ownerships[tokenId].addr = to;
            _ownerships[tokenId].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;
            if (_ownerships[nextTokenId].addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId < _currentIndex) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

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

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

        _beforeTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);

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

        // 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[prevOwnership.addr].balance -= 1;
            _addressData[prevOwnership.addr].numberBurned += 1;

            // Keep track of who burned the token, and the timestamp of burning.
            _ownerships[tokenId].addr = prevOwnership.addr;
            _ownerships[tokenId].startTimestamp = uint64(block.timestamp);
            _ownerships[tokenId].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;
            if (_ownerships[nextTokenId].addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId < _currentIndex) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(prevOwnership.addr, address(0), tokenId);
        _afterTokenTransfers(prevOwnership.addr, 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 {}
}

// File: TKTVPresaleMintPass.sol


pragma solidity 0.8.20;




contract TKTVPresaleMintPass is ERC721A, Ownable {
    using Strings for uint256;

    // Supply
    uint256 public maxSupply = 521;
    uint256 public maxSupplyLimit = 77;

    // URI
    string public baseURI = "https://bafybeigqzgamjl5iyuobtjkop5bnhxoszruwjpeomw4bcq3hbhc2g2ukm4.ipfs.nftstorage.link/";
    string public hiddenURI = "https://bafkreidfdux7klxqgcpom24rf6mkz2zilpk4bcp7kabmyzzmiepnpccncq.ipfs.nftstorage.link/";

    // Costs
    uint256 public whitelistMintCost = 0.0111 ether;

    // Per wallet Limits
    uint256 public nftFreeMintPerWalletLimit = 1;
    uint256 public nftWhitelistMintPerWalletLimit = 1;

    // States
    bool public paused = false;
    bool public freeMintActive = true;
    bool public whitelistMintActive = true;
    bool public revealed = false;

    // Merkle Tree Roots
    bytes32 public freeMintMerkleTreeRoot;
    bytes32 public whitelistMintMerkleTreeRoot;

    // Balances
    mapping(address => uint256) public walletFreeMintBalance;
    mapping(address => uint256) public walletWhitelistMintBalance;

    // Constructor
    constructor() ERC721A("Vindico Studios - TKTV Presale Mint Pass", "TKTV Presale Mint Pass") {}

    // Free Mint - Functions
    function freeMint(uint256 _mintAmount, bytes32[] memory _merkleTreeProof) public payable freeMintCompliance(_mintAmount, _merkleTreeProof) {
        require(!paused, "MSG: The contract is paused");
        require(freeMintActive == true, "MSG: free mint is not live yet");
        
        _safeMint(msg.sender, _mintAmount);

        for (uint256 i = 0; i < _mintAmount; i++) {
            walletFreeMintBalance[msg.sender]++;
        }
    }

    modifier freeMintCompliance(uint256 _mintAmount, bytes32[] memory _merkleTreeProof) {
        uint256 freeMintOwnerMintCount = walletFreeMintBalance[msg.sender];
        uint256 whitelistOwnerMintCount = walletWhitelistMintBalance[msg.sender];

        require(freeMintOwnerMintCount + _mintAmount <= nftFreeMintPerWalletLimit, "MSG: Max NFTs per wallet exceeded for free mint");
        require(whitelistOwnerMintCount + _mintAmount <= nftFreeMintPerWalletLimit, "MSG: Max NFTs per wallet exceeded for whitelist mint");
        require(isValidFreeMintMerkleTreeProof(_merkleTreeProof, keccak256(abi.encodePacked(msg.sender))), "MSG: User is not whitelisted");
        require(totalSupply() + _mintAmount <= maxSupplyLimit, "MSG: Max supply exceeded for current phase");
        require(totalSupply() + _mintAmount <= maxSupply, "MSG: Max supply exceeded");

        _;
    }

    function isValidFreeMintMerkleTreeProof(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
        return MerkleProof.verify(proof, freeMintMerkleTreeRoot, leaf);
    }

    // Whitelist Mint - Functions
    function whitelistMint(uint256 _mintAmount, bytes32[] memory _merkleTreeProof) public payable whitelistMintCompliance(_mintAmount, _merkleTreeProof) {
        require(!paused, "MSG: The contract is paused");
        require(whitelistMintActive == true, "MSG: Whitelist mint is not live yet");

        require(msg.value == whitelistMintCost * _mintAmount, "MSG: Insufficient funds");
        
        _safeMint(msg.sender, _mintAmount);

        for (uint256 i = 0; i < _mintAmount; i++) {
            walletWhitelistMintBalance[msg.sender]++;
        }
    }

    modifier whitelistMintCompliance(uint256 _mintAmount, bytes32[] memory _merkleTreeProof) {
        uint256 freeMintOwnerMintCount = walletFreeMintBalance[msg.sender];
        uint256 whitelistOwnerMintCount = walletWhitelistMintBalance[msg.sender];

        require(freeMintOwnerMintCount + _mintAmount <= nftWhitelistMintPerWalletLimit, "MSG: Max NFTs per wallet exceeded for free mint");
        require(whitelistOwnerMintCount + _mintAmount <= nftWhitelistMintPerWalletLimit, "MSG: Max NFTs per wallet exceeded for whitelist mint");
        require(isValidWhitelistMintMerkleTreeProof(_merkleTreeProof, keccak256(abi.encodePacked(msg.sender))), "MSG: User is not whitelisted");
        require(totalSupply() + _mintAmount <= maxSupplyLimit, "MSG: Max supply exceeded for current phase");
        require(totalSupply() + _mintAmount <= maxSupply, "MSG: Max supply exceeded");

        _;
    }

    function isValidWhitelistMintMerkleTreeProof(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
        return MerkleProof.verify(proof, whitelistMintMerkleTreeRoot, leaf);
    }

    // Owner Mint - Functions
    function ownerMint(uint256 _mintAmount) public onlyOwner {
        require(!paused, "MSG: The contract is paused");
        require(totalSupply() + _mintAmount <= maxSupplyLimit, "MSG: Max supply exceeded for current phase");
        require(totalSupply() + _mintAmount <= maxSupply, "MSG: Max supply exceeded");

        _safeMint(msg.sender, _mintAmount);
    }

    function ownerMintForOthers(address _receiver, uint256 _mintAmount) public onlyOwner {
        require(!paused, "MSG: The contract is paused");
        require(totalSupply() + _mintAmount <= maxSupplyLimit, "MSG: Max supply exceeded for current phase");
        require(totalSupply() + _mintAmount <= maxSupply, "MSG: Max supply exceeded");

        _safeMint(_receiver, _mintAmount);
    }

    // Supply - Functions
    function setMaxSupply(uint256 _supply) public onlyOwner {
        maxSupply = _supply;
    }

    function setMaxSupplyLimit(uint256 _supply) public onlyOwner {
        maxSupplyLimit = _supply;
    }

    // URI - Functions
    function _baseURI() internal view override returns (string memory) {
        return baseURI;
    }

    function setBaseURI(string memory _uri) public onlyOwner {
        baseURI = _uri;
    }

    function setHiddenURI(string memory _uri) public onlyOwner {
        hiddenURI = _uri;
    }

    function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
        require(_exists(_tokenId), "MSG: URI query for nonexistent token.");

        if (revealed == false) {
            return hiddenURI;
        }

        string memory currentBaseURI = _baseURI();

        return bytes(currentBaseURI).length > 0 ? string(abi.encodePacked(currentBaseURI, _tokenId.toString(), ".json")) : "";
    }

    // Cost - Functions
    function setWhitelistMintCost(uint256 _cost) public onlyOwner {
        whitelistMintCost = _cost;
    }

    // Per wallet Limit - Functions
    function setNFTFreeMintPerWalletLimit(uint256 _limit) public onlyOwner {
        nftFreeMintPerWalletLimit = _limit;
    }

    function setNFTWhitelistMintPerWalletLimit(uint256 _limit) public onlyOwner {
        nftWhitelistMintPerWalletLimit = _limit;
    }

    // State - Functions
    function setPaused(bool _state) public onlyOwner {
        paused = _state;
    }

    function setFreeMintActive(bool _state) public onlyOwner {
        freeMintActive = _state;
    }

    function setWhitelistMintActive(bool _state) public onlyOwner {
        whitelistMintActive = _state;
    }

    function setRevealed(bool _state) public onlyOwner {
        revealed = _state;
    }

    // Merkle Tree Root - Functions
    function setFreeMintMerkleTreeRoot(bytes32 _root) public onlyOwner {
        freeMintMerkleTreeRoot = _root;
    }

    function setWhitelistMintMerkleTreeRoot(bytes32 _root) public onlyOwner {
        whitelistMintMerkleTreeRoot = _root;
    }

    // Other Functions
    function walletOfOwner(address _owner) public view returns (uint256[] memory) {
        uint256 ownerTokenCount = balanceOf(_owner);
        uint256[] memory ownedTokenIds = new uint256[](ownerTokenCount);
        uint256 currentTokenId = _startTokenId();
        uint256 ownedTokenIndex = 0;
        address latestOwnerAddress;

        while (ownedTokenIndex < ownerTokenCount && currentTokenId <= maxSupply) {
            TokenOwnership memory ownership = _ownerships[currentTokenId];

            if (!ownership.burned && ownership.addr != address(0)) {
                latestOwnerAddress = ownership.addr;
            }

            if (latestOwnerAddress == _owner) {
                ownedTokenIds[ownedTokenIndex] = currentTokenId;

                ownedTokenIndex++;
            }

            currentTokenId++;
        }

        return ownedTokenIds;
    }

    // Withdraw - Function
    function withdraw() public payable {
        payable(owner()).transfer(address(this).balance);
    }
}

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"},{"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":"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":[{"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":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"},{"internalType":"bytes32[]","name":"_merkleTreeProof","type":"bytes32[]"}],"name":"freeMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"freeMintActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"freeMintMerkleTreeRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hiddenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"bytes32","name":"leaf","type":"bytes32"}],"name":"isValidFreeMintMerkleTreeProof","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"bytes32","name":"leaf","type":"bytes32"}],"name":"isValidWhitelistMintMerkleTreeProof","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupplyLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nftFreeMintPerWalletLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nftWhitelistMintPerWalletLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"ownerMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"ownerMintForOthers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"_uri","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setFreeMintActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_root","type":"bytes32"}],"name":"setFreeMintMerkleTreeRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uri","type":"string"}],"name":"setHiddenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_supply","type":"uint256"}],"name":"setMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_supply","type":"uint256"}],"name":"setMaxSupplyLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_limit","type":"uint256"}],"name":"setNFTFreeMintPerWalletLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_limit","type":"uint256"}],"name":"setNFTWhitelistMintPerWalletLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setRevealed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setWhitelistMintActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cost","type":"uint256"}],"name":"setWhitelistMintCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_root","type":"bytes32"}],"name":"setWhitelistMintMerkleTreeRoot","outputs":[],"stateMutability":"nonpayable","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":"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":"","type":"address"}],"name":"walletFreeMintBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"walletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"walletWhitelistMintBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"},{"internalType":"bytes32[]","name":"_merkleTreeProof","type":"bytes32[]"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"whitelistMintActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistMintCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistMintMerkleTreeRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

72327:8588:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54793:305;;;;;;;;;;-1:-1:-1;54793:305:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;54793:305:0;;;;;;;;58178:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;59681:204::-;;;;;;;;;;-1:-1:-1;59681:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1697:32:1;;;1679:51;;1667:2;1652:18;59681:204:0;1533:203:1;59244:371:0;;;;;;;;;;-1:-1:-1;59244:371:0;;;;;:::i;:::-;;:::i;:::-;;78987:134;;;;;;;;;;-1:-1:-1;78987:134:0;;;;;:::i;:::-;;:::i;79155:83::-;;;;;;;;;;-1:-1:-1;79155:83:0;;;;;:::i;:::-;;:::i;54042:303::-;;;;;;;;;;-1:-1:-1;54296:12:0;;54086:7;54280:13;:28;54042:303;;;2674:25:1;;;2662:2;2647:18;54042:303:0;2528:177:1;79353:109:0;;;;;;;;;;-1:-1:-1;79353:109:0;;;;;:::i;:::-;;:::i;60538:170::-;;;;;;;;;;-1:-1:-1;60538:170:0;;;;;:::i;:::-;;:::i;72919:49::-;;;;;;;;;;;;;;;;76645:196;;;;;;;;;;-1:-1:-1;76645:196:0;;;;;:::i;:::-;;:::i;80810:102::-;;;:::i;60779:185::-;;;;;;;;;;-1:-1:-1;60779:185:0;;;;;:::i;:::-;;:::i;79884:890::-;;;;;;;;;;-1:-1:-1;79884:890:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;79602:116::-;;;;;;;;;;-1:-1:-1;79602:116:0;;;;;:::i;:::-;;:::i;79246:99::-;;;;;;;;;;-1:-1:-1;79246:99:0;;;;;:::i;:::-;;:::i;73110:28::-;;;;;;;;;;-1:-1:-1;73110:28:0;;;;;;;;;;;78034:90;;;;;;;;;;-1:-1:-1;78034:90:0;;;;;:::i;:::-;;:::i;72992:26::-;;;;;;;;;;-1:-1:-1;72992:26:0;;;;;;;;74924:186;;;;;;;;;;-1:-1:-1;74924:186:0;;;;;:::i;:::-;;:::i;57987:124::-;;;;;;;;;;-1:-1:-1;57987:124:0;;;;;:::i;:::-;;:::i;73065:38::-;;;;;;;;;;-1:-1:-1;73065:38:0;;;;;;;;;;;72524:115;;;;;;;;;;;;;:::i;77688:94::-;;;;;;;;;;-1:-1:-1;77688:94:0;;;;;:::i;:::-;;:::i;55162:206::-;;;;;;;;;;-1:-1:-1;55162:206:0;;;;;:::i;:::-;;:::i;29982:103::-;;;;;;;;;;;;;:::i;78855:124::-;;;;;;;;;;-1:-1:-1;78855:124:0;;;;;:::i;:::-;;:::i;78704:106::-;;;;;;;;;;-1:-1:-1;78704:106:0;;;;;:::i;:::-;;:::i;79726:126::-;;;;;;;;;;-1:-1:-1;79726:126:0;;;;;:::i;:::-;;:::i;73285:56::-;;;;;;;;;;-1:-1:-1;73285:56:0;;;;;:::i;:::-;;;;;;;;;;;;;;72646:117;;;;;;;;;;;;;:::i;29341:87::-;;;;;;;;;;-1:-1:-1;29414:6:0;;-1:-1:-1;;;;;29414:6:0;29341:87;;58347:104;;;;;;;;;;;;;:::i;59957:279::-;;;;;;;;;;-1:-1:-1;59957:279:0;;;;;:::i;:::-;;:::i;72786:47::-;;;;;;;;;;;;;;;;72868:44;;;;;;;;;;;;;;;;61035:369;;;;;;;;;;-1:-1:-1;61035:369:0;;;;;:::i;:::-;;:::i;73217:42::-;;;;;;;;;;;;;;;;73348:61;;;;;;;;;;-1:-1:-1;73348:61:0;;;;;:::i;:::-;;;;;;;;;;;;;;78132:94;;;;;;;;;;-1:-1:-1;78132:94:0;;;;;:::i;:::-;;:::i;77257:396::-;;;;;;;;;;-1:-1:-1;77257:396:0;;;;;:::i;:::-;;:::i;73173:37::-;;;;;;;;;;;;;;;;78234:437;;;;;;;;;;-1:-1:-1;78234:437:0;;;;;:::i;:::-;;:::i;73025:33::-;;;;;;;;;;-1:-1:-1;73025:33:0;;;;;;;;;;;75153:570;;;;;;:::i;:::-;;:::i;72432:30::-;;;;;;;;;;;;;;;;79470:87;;;;;;;;;;-1:-1:-1;79470:87:0;;;;;:::i;:::-;;:::i;73570:452::-;;;;;;:::i;:::-;;:::i;77790:104::-;;;;;;;;;;-1:-1:-1;77790:104:0;;;;;:::i;:::-;;:::i;60307:164::-;;;;;;;;;;-1:-1:-1;60307:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;60428:25:0;;;60404:4;60428:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;60307:164;72469:34;;;;;;;;;;;;;;;;76880:369;;;;;;;;;;-1:-1:-1;76880:369:0;;;;;:::i;:::-;;:::i;30240:201::-;;;;;;;;;;-1:-1:-1;30240:201:0;;;;;:::i;:::-;;:::i;54793:305::-;54895:4;-1:-1:-1;;;;;;54932:40:0;;-1:-1:-1;;;54932:40:0;;:105;;-1:-1:-1;;;;;;;54989:48:0;;-1:-1:-1;;;54989:48:0;54932:105;:158;;;-1:-1:-1;;;;;;;;;;43377:40:0;;;55054:36;54912:178;54793:305;-1:-1:-1;;54793:305:0:o;58178:100::-;58232:13;58265:5;58258:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58178:100;:::o;59681:204::-;59749:7;59774:16;59782:7;59774;:16::i;:::-;59769:64;;59799:34;;-1:-1:-1;;;59799:34:0;;;;;;;;;;;59769:64;-1:-1:-1;59853:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;59853:24:0;;59681:204::o;59244:371::-;59317:13;59333:24;59349:7;59333:15;:24::i;:::-;59317:40;;59378:5;-1:-1:-1;;;;;59372:11:0;:2;-1:-1:-1;;;;;59372:11:0;;59368:48;;59392:24;;-1:-1:-1;;;59392:24:0;;;;;;;;;;;59368:48;27972:10;-1:-1:-1;;;;;59433:21:0;;;;;;:63;;-1:-1:-1;59459:37:0;59476:5;27972:10;60307:164;:::i;59459:37::-;59458:38;59433:63;59429:138;;;59520:35;;-1:-1:-1;;;59520:35:0;;;;;;;;;;;59429:138;59579:28;59588:2;59592:7;59601:5;59579:8;:28::i;:::-;59306:309;59244:371;;:::o;78987:134::-;29227:13;:11;:13::i;:::-;79074:30:::1;:39:::0;78987:134::o;79155:83::-;29227:13;:11;:13::i;:::-;79215:6:::1;:15:::0;;-1:-1:-1;;79215:15:0::1;::::0;::::1;;::::0;;;::::1;::::0;;79155:83::o;79353:109::-;29227:13;:11;:13::i;:::-;79426:19:::1;:28:::0;;;::::1;;::::0;::::1;-1:-1:-1::0;;79426:28:0;;::::1;::::0;;;::::1;::::0;;79353:109::o;60538:170::-;60672:28;60682:4;60688:2;60692:7;60672:9;:28::i;76645:196::-;76749:4;76773:60;76792:5;76799:27;;76828:4;76773:18;:60::i;:::-;76766:67;76645:196;-1:-1:-1;;;76645:196:0:o;80810:102::-;29414:6;;80856:48;;-1:-1:-1;;;;;29414:6:0;;;;80882:21;80856:48;;;;;;;;;80882:21;29414:6;80856:48;;;;;;;;;;;;;;;;;;;;;80810:102::o;60779:185::-;60917:39;60934:4;60940:2;60944:7;60917:39;;;;;;;;;;;;:16;:39::i;79884:890::-;79944:16;79973:23;79999:17;80009:6;79999:9;:17::i;:::-;79973:43;;80027:30;80074:15;-1:-1:-1;;;;;80060:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;80060:30:0;-1:-1:-1;80027:63:0;-1:-1:-1;80101:22:0;80152:23;80190:26;80229:505;80254:15;80236;:33;:64;;;;;80291:9;;80273:14;:27;;80236:64;80229:505;;;80317:31;80351:27;;;:11;:27;;;;;;;;;80317:61;;;;;;;;;-1:-1:-1;;;;;80317:61:0;;;;-1:-1:-1;;;80317:61:0;;-1:-1:-1;;;;;80317:61:0;;;;;;;;-1:-1:-1;;;80317:61:0;;;;;;;;;;;;;;;;80399:49;;-1:-1:-1;80420:14:0;;-1:-1:-1;;;;;80420:28:0;;;80399:49;80395:125;;;80490:14;;;-1:-1:-1;80395:125:0;80562:6;-1:-1:-1;;;;;80540:28:0;:18;-1:-1:-1;;;;;80540:28:0;;80536:154;;80622:14;80589:13;80603:15;80589:30;;;;;;;;:::i;:::-;;;;;;;;;;:47;80657:17;;;;:::i;:::-;;;;80536:154;80706:16;;;;:::i;:::-;;;;80302:432;80229:505;;;-1:-1:-1;80753:13:0;;79884:890;-1:-1:-1;;;;;79884:890:0:o;79602:116::-;29227:13;:11;:13::i;:::-;79680:22:::1;:30:::0;79602:116::o;79246:99::-;29227:13;:11;:13::i;:::-;79314:14:::1;:23:::0;;;::::1;;;;-1:-1:-1::0;;79314:23:0;;::::1;::::0;;;::::1;::::0;;79246:99::o;78034:90::-;29227:13;:11;:13::i;:::-;78102:7:::1;:14;78112:4:::0;78102:7;:14:::1;:::i;:::-;;78034:90:::0;:::o;74924:186::-;75023:4;75047:55;75066:5;75073:22;;75097:4;75047:18;:55::i;57987:124::-;58051:7;58078:20;58090:7;58078:11;:20::i;:::-;:25;;57987:124;-1:-1:-1;;57987:124:0:o;72524:115::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;77688:94::-;29227:13;:11;:13::i;:::-;77755:9:::1;:19:::0;77688:94::o;55162:206::-;55226:7;-1:-1:-1;;;;;55250:19:0;;55246:60;;55278:28;;-1:-1:-1;;;55278:28:0;;;;;;;;;;;55246:60;-1:-1:-1;;;;;;55332:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;55332:27:0;;55162:206::o;29982:103::-;29227:13;:11;:13::i;:::-;30047:30:::1;30074:1;30047:18;:30::i;:::-;29982:103::o:0;78855:124::-;29227:13;:11;:13::i;:::-;78937:25:::1;:34:::0;78855:124::o;78704:106::-;29227:13;:11;:13::i;:::-;78777:17:::1;:25:::0;78704:106::o;79726:126::-;29227:13;:11;:13::i;:::-;79809:27:::1;:35:::0;79726:126::o;72646:117::-;;;;;;;:::i;58347:104::-;58403:13;58436:7;58429:14;;;;;:::i;59957:279::-;27972:10;-1:-1:-1;;;;;60048:24:0;;;60044:54;;60081:17;;-1:-1:-1;;;60081:17:0;;;;;;;;;;;60044:54;27972:10;60111:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;60111:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;60111:53:0;;;;;;;;;;60180:48;;540:41:1;;;60111:42:0;;27972:10;60180:48;;513:18:1;60180:48:0;;;;;;;59957:279;;:::o;61035:369::-;61202:28;61212:4;61218:2;61222:7;61202:9;:28::i;:::-;-1:-1:-1;;;;;61245:13:0;;32568:19;:23;;61245:76;;;;;61265:56;61296:4;61302:2;61306:7;61315:5;61265:30;:56::i;:::-;61264:57;61245:76;61241:156;;;61345:40;;-1:-1:-1;;;61345:40:0;;;;;;;;;;;61241:156;61035:369;;;;:::o;78132:94::-;29227:13;:11;:13::i;:::-;78202:9:::1;:16;78214:4:::0;78202:9;:16:::1;:::i;77257:396::-:0;29227:13;:11;:13::i;:::-;77362:6:::1;::::0;::::1;;77361:7;77353:47;;;;-1:-1:-1::0;;;77353:47:0::1;;;;;;;:::i;:::-;;;;;;;;;77450:14;;77435:11;77419:13;54296:12:::0;;54086:7;54280:13;:28;;54042:303;77419:13:::1;:27;;;;:::i;:::-;:45;;77411:100;;;;-1:-1:-1::0;;;77411:100:0::1;;;;;;;:::i;:::-;77561:9;;77546:11;77530:13;54296:12:::0;;54086:7;54280:13;:28;;54042:303;77530:13:::1;:27;;;;:::i;:::-;:40;;77522:77;;;;-1:-1:-1::0;;;77522:77:0::1;;;;;;;:::i;:::-;77612:33;77622:9;77633:11;77612:9;:33::i;78234:437::-:0;78308:13;78342:17;78350:8;78342:7;:17::i;:::-;78334:67;;;;-1:-1:-1;;;78334:67:0;;12718:2:1;78334:67:0;;;12700:21:1;12757:2;12737:18;;;12730:30;12796:34;12776:18;;;12769:62;-1:-1:-1;;;12847:18:1;;;12840:35;12892:19;;78334:67:0;12516:401:1;78334:67:0;78418:8;;;;;;;:17;;78430:5;78418:17;78414:66;;78459:9;78452:16;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78234:437;;;:::o;78414:66::-;78492:28;78523:10;:8;:10::i;:::-;78492:41;;78584:1;78559:14;78553:28;:32;:110;;;;;;;;;;;;;;;;;78612:14;78628:19;:8;:17;:19::i;:::-;78595:62;;;;;;;;;:::i;:::-;;;;;;;;;;;;;78546:117;78234:437;-1:-1:-1;;;78234:437:0:o;75153:570::-;75886:10;75831:30;75864:33;;;:21;:33;;;;;;;;;75942:26;:38;;;;;;;76041:30;;75271:11;;75284:16;;75864:33;;76001:36;75271:11;75864:33;76001:36;:::i;:::-;:70;;75993:130;;;;-1:-1:-1;;;75993:130:0;;;;;;;:::i;:::-;76183:30;;76142:37;76168:11;76142:23;:37;:::i;:::-;:71;;76134:136;;;;-1:-1:-1;;;76134:136:0;;;;;;;:::i;:::-;76353:28;;-1:-1:-1;;76370:10:0;14576:2:1;14572:15;14568:53;76353:28:0;;;14556:66:1;76289:94:0;;76325:16;;14638:12:1;;76353:28:0;;;;;;;;;;;;76343:39;;;;;;76289:35;:94::i;:::-;76281:135;;;;-1:-1:-1;;;76281:135:0;;14863:2:1;76281:135:0;;;14845:21:1;14902:2;14882:18;;;14875:30;14941;14921:18;;;14914:58;14989:18;;76281:135:0;14661:352:1;76281:135:0;76466:14;;76451:11;76435:13;54296:12;;54086:7;54280:13;:28;;54042:303;76435:13;:27;;;;:::i;:::-;:45;;76427:100;;;;-1:-1:-1;;;76427:100:0;;;;;;;:::i;:::-;76577:9;;76562:11;76546:13;54296:12;;54086:7;54280:13;:28;;54042:303;76546:13;:27;;;;:::i;:::-;:40;;76538:77;;;;-1:-1:-1;;;76538:77:0;;;;;;;:::i;:::-;75322:6:::1;::::0;::::1;;75321:7;75313:47;;;;-1:-1:-1::0;;;75313:47:0::1;;;;;;;:::i;:::-;75379:19;::::0;;;::::1;;;:27;;75402:4;75379:27;75371:75;;;::::0;-1:-1:-1;;;75371:75:0;;15220:2:1;75371:75:0::1;::::0;::::1;15202:21:1::0;15259:2;15239:18;;;15232:30;15298:34;15278:18;;;15271:62;-1:-1:-1;;;15349:18:1;;;15342:33;15392:19;;75371:75:0::1;15018:399:1::0;75371:75:0::1;75500:11;75480:17;;:31;;;;:::i;:::-;75467:9;:44;75459:80;;;::::0;-1:-1:-1;;;75459:80:0;;15797:2:1;75459:80:0::1;::::0;::::1;15779:21:1::0;15836:2;15816:18;;;15809:30;15875:25;15855:18;;;15848:53;15918:18;;75459:80:0::1;15595:347:1::0;75459:80:0::1;75560:34;75570:10;75582:11;75560:9;:34::i;:::-;75612:9;75607:109;75631:11;75627:1;:15;75607:109;;;75691:10;75664:38;::::0;;;:26:::1;:38;::::0;;;;:40;;;::::1;::::0;::::1;:::i;:::-;;;;;;75644:3;;;;;:::i;:::-;;;;75607:109;;;;75820:817:::0;;75153:570;;;;:::o;79470:87::-;29227:13;:11;:13::i;:::-;79532:8:::1;:17:::0;;;::::1;;::::0;::::1;-1:-1:-1::0;;79532:17:0;;::::1;::::0;;;::::1;::::0;;79470:87::o;73570:452::-;74180:10;74125:30;74158:33;;;:21;:33;;;;;;;;;74236:26;:38;;;;;;;74335:25;;73678:11;;73691:16;;74158:33;;74295:36;73678:11;74158:33;74295:36;:::i;:::-;:65;;74287:125;;;;-1:-1:-1;;;74287:125:0;;;;;;;:::i;:::-;74472:25;;74431:37;74457:11;74431:23;:37;:::i;:::-;:66;;74423:131;;;;-1:-1:-1;;;74423:131:0;;;;;;;:::i;:::-;74632:28;;-1:-1:-1;;74649:10:0;14576:2:1;14572:15;14568:53;74632:28:0;;;14556:66:1;74573:89:0;;74604:16;;14638:12:1;;74632:28:0;;;;;;;;;;;;74622:39;;;;;;74573:30;:89::i;:::-;74565:130;;;;-1:-1:-1;;;74565:130:0;;14863:2:1;74565:130:0;;;14845:21:1;14902:2;14882:18;;;14875:30;14941;14921:18;;;14914:58;14989:18;;74565:130:0;14661:352:1;74565:130:0;74745:14;;74730:11;74714:13;54296:12;;54086:7;54280:13;:28;;54042:303;74714:13;:27;;;;:::i;:::-;:45;;74706:100;;;;-1:-1:-1;;;74706:100:0;;;;;;;:::i;:::-;74856:9;;74841:11;74825:13;54296:12;;54086:7;54280:13;:28;;54042:303;74825:13;:27;;;;:::i;:::-;:40;;74817:77;;;;-1:-1:-1;;;74817:77:0;;;;;;;:::i;:::-;73729:6:::1;::::0;::::1;;73728:7;73720:47;;;;-1:-1:-1::0;;;73720:47:0::1;;;;;;;:::i;:::-;73786:14;::::0;::::1;;::::0;;::::1;;:22;;:14;:22;73778:65;;;::::0;-1:-1:-1;;;73778:65:0;;16149:2:1;73778:65:0::1;::::0;::::1;16131:21:1::0;16188:2;16168:18;;;16161:30;16227:32;16207:18;;;16200:60;16277:18;;73778:65:0::1;15947:354:1::0;73778:65:0::1;73864:34;73874:10;73886:11;73864:9;:34::i;:::-;73916:9;73911:104;73935:11;73931:1;:15;73911:104;;;73990:10;73968:33;::::0;;;:21:::1;:33;::::0;;;;:35;;;::::1;::::0;::::1;:::i;:::-;;;;;;73948:3;;;;;:::i;:::-;;;;73911:104;;77790::::0;29227:13;:11;:13::i;:::-;77862:14:::1;:24:::0;77790:104::o;76880:369::-;29227:13;:11;:13::i;:::-;76957:6:::1;::::0;::::1;;76956:7;76948:47;;;;-1:-1:-1::0;;;76948:47:0::1;;;;;;;:::i;:::-;77045:14;;77030:11;77014:13;54296:12:::0;;54086:7;54280:13;:28;;54042:303;77014:13:::1;:27;;;;:::i;:::-;:45;;77006:100;;;;-1:-1:-1::0;;;77006:100:0::1;;;;;;;:::i;:::-;77156:9;;77141:11;77125:13;54296:12:::0;;54086:7;54280:13;:28;;54042:303;77125:13:::1;:27;;;;:::i;:::-;:40;;77117:77;;;;-1:-1:-1::0;;;77117:77:0::1;;;;;;;:::i;:::-;77207:34;77217:10;77229:11;77207:9;:34::i;30240:201::-:0;29227:13;:11;:13::i;:::-;-1:-1:-1;;;;;30329:22:0;::::1;30321:73;;;::::0;-1:-1:-1;;;30321:73:0;;16508:2:1;30321:73:0::1;::::0;::::1;16490:21:1::0;16547:2;16527:18;;;16520:30;16586:34;16566:18;;;16559:62;-1:-1:-1;;;16637:18:1;;;16630:36;16683:19;;30321:73:0::1;16306:402:1::0;30321:73:0::1;30405:28;30424:8;30405:18;:28::i;61659:187::-:0;61716:4;61780:13;;61770:7;:23;61740:98;;;;-1:-1:-1;;61811:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;61811:27:0;;;;61810:28;;61659:187::o;69270:196::-;69385:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;69385:29:0;-1:-1:-1;;;;;69385:29:0;;;;;;;;;69430:28;;69385:24;;69430:28;;;;;;;69270:196;;;:::o;29506:132::-;29414:6;;-1:-1:-1;;;;;29414:6:0;27972:10;29570:23;29562:68;;;;-1:-1:-1;;;29562:68:0;;16915:2:1;29562:68:0;;;16897:21:1;;;16934:18;;;16927:30;16993:34;16973:18;;;16966:62;17045:18;;29562:68:0;16713:356:1;64772:2112:0;64887:35;64925:20;64937:7;64925:11;:20::i;:::-;65000:18;;64887:58;;-1:-1:-1;64958:22:0;;-1:-1:-1;;;;;64984:34:0;27972:10;-1:-1:-1;;;;;64984:34:0;;:101;;;-1:-1:-1;65052:18:0;;65035:50;;27972:10;60307:164;:::i;65035:50::-;64984:154;;;-1:-1:-1;27972:10:0;65102:20;65114:7;65102:11;:20::i;:::-;-1:-1:-1;;;;;65102:36:0;;64984:154;64958:181;;65157:17;65152:66;;65183:35;;-1:-1:-1;;;65183:35:0;;;;;;;;;;;65152:66;65255:4;-1:-1:-1;;;;;65233:26:0;:13;:18;;;-1:-1:-1;;;;;65233:26:0;;65229:67;;65268:28;;-1:-1:-1;;;65268:28:0;;;;;;;;;;;65229:67;-1:-1:-1;;;;;65311:16:0;;65307:52;;65336:23;;-1:-1:-1;;;65336:23:0;;;;;;;;;;;65307:52;65480:49;65497:1;65501:7;65510:13;:18;;;65480:8;:49::i;:::-;-1:-1:-1;;;;;65825:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;65825:31:0;;;-1:-1:-1;;;;;65825:31:0;;;-1:-1:-1;;65825:31:0;;;;;;;65871:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;65871:29:0;;;;;;;;;;;65917:20;;;:11;:20;;;;;;:30;;-1:-1:-1;;;;;;65962:61:0;;;;-1:-1:-1;;;66007:15:0;65962:61;;;;;;;;;;;66297:11;;;66327:24;;;;;:29;66297:11;;66327:29;66323:445;;66552:13;;66538:11;:27;66534:219;;;66622:18;;;66590:24;;;:11;:24;;;;;;;;:50;;66705:28;;;;-1:-1:-1;;;;;66663:70:0;-1:-1:-1;;;66663:70:0;-1:-1:-1;;;;;;66663:70:0;;;-1:-1:-1;;;;;66590:50:0;;;66663:70;;;;;;;66534:219;65800:979;66815:7;66811:2;-1:-1:-1;;;;;66796:27:0;66805:4;-1:-1:-1;;;;;66796:27:0;;;;;;;;;;;66834:42;64876:2008;;64772:2112;;;:::o;1222:156::-;1313:4;1366;1337:25;1350:5;1357:4;1337:12;:25::i;:::-;:33;;1222:156;-1:-1:-1;;;;1222:156:0:o;56817:1108::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;56927:7:0;57010:13;;57003:4;:20;56972:886;;;57044:31;57078:17;;;:11;:17;;;;;;;;;57044:51;;;;;;;;;-1:-1:-1;;;;;57044:51:0;;;;-1:-1:-1;;;57044:51:0;;-1:-1:-1;;;;;57044:51:0;;;;;;;;-1:-1:-1;;;57044:51:0;;;;;;;;;;;;;;57114:729;;57164:14;;-1:-1:-1;;;;;57164:28:0;;57160:101;;57228:9;56817:1108;-1:-1:-1;;;56817:1108:0:o;57160:101::-;-1:-1:-1;;;57603:6:0;57648:17;;;;:11;:17;;;;;;;;;57636:29;;;;;;;;;-1:-1:-1;;;;;57636:29:0;;;;;-1:-1:-1;;;57636:29:0;;-1:-1:-1;;;;;57636:29:0;;;;;;;;-1:-1:-1;;;57636:29:0;;;;;;;;;;;;;57696:28;57692:109;;57764:9;56817:1108;-1:-1:-1;;;56817:1108:0:o;57692:109::-;57563:261;;;57025:833;56972:886;57886:31;;-1:-1:-1;;;57886:31:0;;;;;;;;;;;30601:191;30694:6;;;-1:-1:-1;;;;;30711:17:0;;;-1:-1:-1;;;;;;30711:17:0;;;;;;;30744:40;;30694:6;;;30711:17;30694:6;;30744:40;;30675:16;;30744:40;30664:128;30601:191;:::o;69958:667::-;70142:72;;-1:-1:-1;;;70142:72:0;;70121:4;;-1:-1:-1;;;;;70142:36:0;;;;;:72;;27972:10;;70193:4;;70199:7;;70208:5;;70142:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;70142:72:0;;;;;;;;-1:-1:-1;;70142:72:0;;;;;;;;;;;;:::i;:::-;;;70138:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70376:6;:13;70393:1;70376:18;70372:235;;70422:40;;-1:-1:-1;;;70422:40:0;;;;;;;;;;;70372:235;70565:6;70559:13;70550:6;70546:2;70542:15;70535:38;70138:480;-1:-1:-1;;;;;;70261:55:0;-1:-1:-1;;;70261:55:0;;-1:-1:-1;70138:480:0;69958:667;;;;;;:::o;61854:104::-;61923:27;61933:2;61937:8;61923:27;;;;;;;;;;;;:9;:27::i;77926:100::-;77978:13;78011:7;78004:14;;;;;:::i;24811:716::-;24867:13;24918:14;24935:17;24946:5;24935:10;:17::i;:::-;24955:1;24935:21;24918:38;;24971:20;25005:6;-1:-1:-1;;;;;24994:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24994:18:0;-1:-1:-1;24971:41:0;-1:-1:-1;25136:28:0;;;25152:2;25136:28;25193:288;-1:-1:-1;;25225:5:0;-1:-1:-1;;;25362:2:0;25351:14;;25346:30;25225:5;25333:44;25423:2;25414:11;;;-1:-1:-1;25444:21:0;25193:288;25444:21;-1:-1:-1;25502:6:0;24811:716;-1:-1:-1;;;24811:716:0:o;2021:296::-;2104:7;2147:4;2104:7;2162:118;2186:5;:12;2182:1;:16;2162:118;;;2235:33;2245:12;2259:5;2265:1;2259:8;;;;;;;;:::i;:::-;;;;;;;2235:9;:33::i;:::-;2220:48;-1:-1:-1;2200:3:0;;;;:::i;:::-;;;;2162:118;;;-1:-1:-1;2297:12:0;2021:296;-1:-1:-1;;;2021:296:0:o;62321:163::-;62444:32;62450:2;62454:8;62464:5;62471:4;62444:5;:32::i;21645:948::-;21698:7;;-1:-1:-1;;;21776:17:0;;21772:106;;-1:-1:-1;;;21814:17:0;;;-1:-1:-1;21860:2:0;21850:12;21772:106;21905:8;21896:5;:17;21892:106;;21943:8;21934:17;;;-1:-1:-1;21980:2:0;21970:12;21892:106;22025:8;22016:5;:17;22012:106;;22063:8;22054:17;;;-1:-1:-1;22100:2:0;22090:12;22012:106;22145:7;22136:5;:16;22132:103;;22182:7;22173:16;;;-1:-1:-1;22218:1:0;22208:11;22132:103;22262:7;22253:5;:16;22249:103;;22299:7;22290:16;;;-1:-1:-1;22335:1:0;22325:11;22249:103;22379:7;22370:5;:16;22366:103;;22416:7;22407:16;;;-1:-1:-1;22452:1:0;22442:11;22366:103;22496:7;22487:5;:16;22483:68;;22534:1;22524:11;22579:6;21645:948;-1:-1:-1;;21645:948:0:o;9459:149::-;9522:7;9553:1;9549;:5;:51;;9684:13;9778:15;;;9814:4;9807:15;;;9861:4;9845:21;;9549:51;;;9684:13;9778:15;;;9814:4;9807:15;;;9861:4;9845:21;;9557:20;9616:268;62743:1775;62882:20;62905:13;-1:-1:-1;;;;;62933:16:0;;62929:48;;62958:19;;-1:-1:-1;;;62958:19:0;;;;;;;;;;;62929:48;62992:8;63004:1;62992:13;62988:44;;63014:18;;-1:-1:-1;;;63014:18:0;;;;;;;;;;;62988:44;-1:-1:-1;;;;;63383:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;63442:49:0;;-1:-1:-1;;;;;63383:44:0;;;;;;;63442:49;;;;-1:-1:-1;;63383:44:0;;;;;;63442:49;;;;;;;;;;;;;;;;63508:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;63558:66:0;;;;-1:-1:-1;;;63608:15:0;63558:66;;;;;;;;;;63508:25;63705:23;;;63749:4;:23;;;;-1:-1:-1;;;;;;63757:13:0;;32568:19;:23;;63757:15;63745:641;;;63793:314;63824:38;;63849:12;;-1:-1:-1;;;;;63824:38:0;;;63841:1;;63824:38;;63841:1;;63824:38;63890:69;63929:1;63933:2;63937:14;;;;;;63953:5;63890:30;:69::i;:::-;63885:174;;63995:40;;-1:-1:-1;;;63995:40:0;;;;;;;;;;;63885:174;64102:3;64086:12;:19;63793:314;;64188:12;64171:13;;:29;64167:43;;64202:8;;;64167:43;63745:641;;;64251:120;64282:40;;64307:14;;;;;-1:-1:-1;;;;;64282:40:0;;;64299:1;;64282:40;;64299:1;;64282:40;64366:3;64350:12;:19;64251:120;;63745:641;-1:-1:-1;64400:13:0;:28;64450:60;61035:369;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;592:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:1;816:16;;809:27;592:250::o;847:271::-;889:3;927:5;921:12;954:6;949:3;942:19;970:76;1039:6;1032:4;1027:3;1023:14;1016:4;1009:5;1005:16;970:76;:::i;:::-;1100:2;1079:15;-1:-1:-1;;1075:29:1;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:1:o;1123:220::-;1272:2;1261:9;1254:21;1235:4;1292:45;1333:2;1322:9;1318:18;1310:6;1292:45;:::i;1348:180::-;1407:6;1460:2;1448:9;1439:7;1435:23;1431:32;1428:52;;;1476:1;1473;1466:12;1428:52;-1:-1:-1;1499:23:1;;1348:180;-1:-1:-1;1348:180:1:o;1741:173::-;1809:20;;-1:-1:-1;;;;;1858:31:1;;1848:42;;1838:70;;1904:1;1901;1894:12;1838:70;1741:173;;;:::o;1919:254::-;1987:6;1995;2048:2;2036:9;2027:7;2023:23;2019:32;2016:52;;;2064:1;2061;2054:12;2016:52;2087:29;2106:9;2087:29;:::i;:::-;2077:39;2163:2;2148:18;;;;2135:32;;-1:-1:-1;;;1919:254:1:o;2178:160::-;2243:20;;2299:13;;2292:21;2282:32;;2272:60;;2328:1;2325;2318:12;2343:180;2399:6;2452:2;2440:9;2431:7;2427:23;2423:32;2420:52;;;2468:1;2465;2458:12;2420:52;2491:26;2507:9;2491:26;:::i;2710:328::-;2787:6;2795;2803;2856:2;2844:9;2835:7;2831:23;2827:32;2824:52;;;2872:1;2869;2862:12;2824:52;2895:29;2914:9;2895:29;:::i;:::-;2885:39;;2943:38;2977:2;2966:9;2962:18;2943:38;:::i;:::-;2933:48;;3028:2;3017:9;3013:18;3000:32;2990:42;;2710:328;;;;;:::o;3043:127::-;3104:10;3099:3;3095:20;3092:1;3085:31;3135:4;3132:1;3125:15;3159:4;3156:1;3149:15;3175:275;3246:2;3240:9;3311:2;3292:13;;-1:-1:-1;;3288:27:1;3276:40;;-1:-1:-1;;;;;3331:34:1;;3367:22;;;3328:62;3325:88;;;3393:18;;:::i;:::-;3429:2;3422:22;3175:275;;-1:-1:-1;3175:275:1:o;3455:712::-;3509:5;3562:3;3555:4;3547:6;3543:17;3539:27;3529:55;;3580:1;3577;3570:12;3529:55;3616:6;3603:20;3642:4;-1:-1:-1;;;;;3661:2:1;3658:26;3655:52;;;3687:18;;:::i;:::-;3733:2;3730:1;3726:10;3756:28;3780:2;3776;3772:11;3756:28;:::i;:::-;3818:15;;;3888;;;3884:24;;;3849:12;;;;3920:15;;;3917:35;;;3948:1;3945;3938:12;3917:35;3984:2;3976:6;3972:15;3961:26;;3996:142;4012:6;4007:3;4004:15;3996:142;;;4078:17;;4066:30;;4029:12;;;;4116;;;;3996:142;;;4156:5;3455:712;-1:-1:-1;;;;;;;3455:712:1:o;4172:416::-;4265:6;4273;4326:2;4314:9;4305:7;4301:23;4297:32;4294:52;;;4342:1;4339;4332:12;4294:52;4382:9;4369:23;-1:-1:-1;;;;;4407:6:1;4404:30;4401:50;;;4447:1;4444;4437:12;4401:50;4470:61;4523:7;4514:6;4503:9;4499:22;4470:61;:::i;:::-;4460:71;4578:2;4563:18;;;;4550:32;;-1:-1:-1;;;;4172:416:1:o;4593:186::-;4652:6;4705:2;4693:9;4684:7;4680:23;4676:32;4673:52;;;4721:1;4718;4711:12;4673:52;4744:29;4763:9;4744:29;:::i;4784:632::-;4955:2;5007:21;;;5077:13;;4980:18;;;5099:22;;;4926:4;;4955:2;5178:15;;;;5152:2;5137:18;;;4926:4;5221:169;5235:6;5232:1;5229:13;5221:169;;;5296:13;;5284:26;;5365:15;;;;5330:12;;;;5257:1;5250:9;5221:169;;;-1:-1:-1;5407:3:1;;4784:632;-1:-1:-1;;;;;;4784:632:1:o;5606:407::-;5671:5;-1:-1:-1;;;;;5697:6:1;5694:30;5691:56;;;5727:18;;:::i;:::-;5765:57;5810:2;5789:15;;-1:-1:-1;;5785:29:1;5816:4;5781:40;5765:57;:::i;:::-;5756:66;;5845:6;5838:5;5831:21;5885:3;5876:6;5871:3;5867:16;5864:25;5861:45;;;5902:1;5899;5892:12;5861:45;5951:6;5946:3;5939:4;5932:5;5928:16;5915:43;6005:1;5998:4;5989:6;5982:5;5978:18;5974:29;5967:40;5606:407;;;;;:::o;6018:451::-;6087:6;6140:2;6128:9;6119:7;6115:23;6111:32;6108:52;;;6156:1;6153;6146:12;6108:52;6196:9;6183:23;-1:-1:-1;;;;;6221:6:1;6218:30;6215:50;;;6261:1;6258;6251:12;6215:50;6284:22;;6337:4;6329:13;;6325:27;-1:-1:-1;6315:55:1;;6366:1;6363;6356:12;6315:55;6389:74;6455:7;6450:2;6437:16;6432:2;6428;6424:11;6389:74;:::i;6474:254::-;6539:6;6547;6600:2;6588:9;6579:7;6575:23;6571:32;6568:52;;;6616:1;6613;6606:12;6568:52;6639:29;6658:9;6639:29;:::i;:::-;6629:39;;6687:35;6718:2;6707:9;6703:18;6687:35;:::i;:::-;6677:45;;6474:254;;;;;:::o;6733:667::-;6828:6;6836;6844;6852;6905:3;6893:9;6884:7;6880:23;6876:33;6873:53;;;6922:1;6919;6912:12;6873:53;6945:29;6964:9;6945:29;:::i;:::-;6935:39;;6993:38;7027:2;7016:9;7012:18;6993:38;:::i;:::-;6983:48;;7078:2;7067:9;7063:18;7050:32;7040:42;;7133:2;7122:9;7118:18;7105:32;-1:-1:-1;;;;;7152:6:1;7149:30;7146:50;;;7192:1;7189;7182:12;7146:50;7215:22;;7268:4;7260:13;;7256:27;-1:-1:-1;7246:55:1;;7297:1;7294;7287:12;7246:55;7320:74;7386:7;7381:2;7368:16;7363:2;7359;7355:11;7320:74;:::i;:::-;7310:84;;;6733:667;;;;;;;:::o;7587:416::-;7680:6;7688;7741:2;7729:9;7720:7;7716:23;7712:32;7709:52;;;7757:1;7754;7747:12;7709:52;7793:9;7780:23;7770:33;;7854:2;7843:9;7839:18;7826:32;-1:-1:-1;;;;;7873:6:1;7870:30;7867:50;;;7913:1;7910;7903:12;7867:50;7936:61;7989:7;7980:6;7969:9;7965:22;7936:61;:::i;:::-;7926:71;;;7587:416;;;;;:::o;8008:260::-;8076:6;8084;8137:2;8125:9;8116:7;8112:23;8108:32;8105:52;;;8153:1;8150;8143:12;8105:52;8176:29;8195:9;8176:29;:::i;:::-;8166:39;;8224:38;8258:2;8247:9;8243:18;8224:38;:::i;8273:380::-;8352:1;8348:12;;;;8395;;;8416:61;;8470:4;8462:6;8458:17;8448:27;;8416:61;8523:2;8515:6;8512:14;8492:18;8489:38;8486:161;;8569:10;8564:3;8560:20;8557:1;8550:31;8604:4;8601:1;8594:15;8632:4;8629:1;8622:15;8486:161;;8273:380;;;:::o;8658:127::-;8719:10;8714:3;8710:20;8707:1;8700:31;8750:4;8747:1;8740:15;8774:4;8771:1;8764:15;8790:127;8851:10;8846:3;8842:20;8839:1;8832:31;8882:4;8879:1;8872:15;8906:4;8903:1;8896:15;8922:135;8961:3;8982:17;;;8979:43;;9002:18;;:::i;:::-;-1:-1:-1;9049:1:1;9038:13;;8922:135::o;9188:545::-;9290:2;9285:3;9282:11;9279:448;;;9326:1;9351:5;9347:2;9340:17;9396:4;9392:2;9382:19;9466:2;9454:10;9450:19;9447:1;9443:27;9437:4;9433:38;9502:4;9490:10;9487:20;9484:47;;;-1:-1:-1;9525:4:1;9484:47;9580:2;9575:3;9571:12;9568:1;9564:20;9558:4;9554:31;9544:41;;9635:82;9653:2;9646:5;9643:13;9635:82;;;9698:17;;;9679:1;9668:13;9635:82;;;9639:3;;;9188:545;;;:::o;9909:1352::-;10035:3;10029:10;-1:-1:-1;;;;;10054:6:1;10051:30;10048:56;;;10084:18;;:::i;:::-;10113:97;10203:6;10163:38;10195:4;10189:11;10163:38;:::i;:::-;10157:4;10113:97;:::i;:::-;10265:4;;10329:2;10318:14;;10346:1;10341:663;;;;11048:1;11065:6;11062:89;;;-1:-1:-1;11117:19:1;;;11111:26;11062:89;-1:-1:-1;;9866:1:1;9862:11;;;9858:24;9854:29;9844:40;9890:1;9886:11;;;9841:57;11164:81;;10311:944;;10341:663;9135:1;9128:14;;;9172:4;9159:18;;-1:-1:-1;;10377:20:1;;;10495:236;10509:7;10506:1;10503:14;10495:236;;;10598:19;;;10592:26;10577:42;;10690:27;;;;10658:1;10646:14;;;;10525:19;;10495:236;;;10499:3;10759:6;10750:7;10747:19;10744:201;;;10820:19;;;10814:26;-1:-1:-1;;10903:1:1;10899:14;;;10915:3;10895:24;10891:37;10887:42;10872:58;10857:74;;10744:201;-1:-1:-1;;;;;10991:1:1;10975:14;;;10971:22;10958:36;;-1:-1:-1;9909:1352:1:o;11266:351::-;11468:2;11450:21;;;11507:2;11487:18;;;11480:30;11546:29;11541:2;11526:18;;11519:57;11608:2;11593:18;;11266:351::o;11622:125::-;11687:9;;;11708:10;;;11705:36;;;11721:18;;:::i;11752:406::-;11954:2;11936:21;;;11993:2;11973:18;;;11966:30;12032:34;12027:2;12012:18;;12005:62;-1:-1:-1;;;12098:2:1;12083:18;;12076:40;12148:3;12133:19;;11752:406::o;12163:348::-;12365:2;12347:21;;;12404:2;12384:18;;;12377:30;12443:26;12438:2;12423:18;;12416:54;12502:2;12487:18;;12163:348::o;12922:663::-;13202:3;13240:6;13234:13;13256:66;13315:6;13310:3;13303:4;13295:6;13291:17;13256:66;:::i;:::-;13385:13;;13344:16;;;;13407:70;13385:13;13344:16;13454:4;13442:17;;13407:70;:::i;:::-;-1:-1:-1;;;13499:20:1;;13528:22;;;13577:1;13566:13;;12922:663;-1:-1:-1;;;;12922:663:1:o;13590:411::-;13792:2;13774:21;;;13831:2;13811:18;;;13804:30;13870:34;13865:2;13850:18;;13843:62;-1:-1:-1;;;13936:2:1;13921:18;;13914:45;13991:3;13976:19;;13590:411::o;14006:416::-;14208:2;14190:21;;;14247:2;14227:18;;;14220:30;14286:34;14281:2;14266:18;;14259:62;-1:-1:-1;;;14352:2:1;14337:18;;14330:50;14412:3;14397:19;;14006:416::o;15422:168::-;15495:9;;;15526;;15543:15;;;15537:22;;15523:37;15513:71;;15564:18;;:::i;17074:489::-;-1:-1:-1;;;;;17343:15:1;;;17325:34;;17395:15;;17390:2;17375:18;;17368:43;17442:2;17427:18;;17420:34;;;17490:3;17485:2;17470:18;;17463:31;;;17268:4;;17511:46;;17537:19;;17529:6;17511:46;:::i;:::-;17503:54;17074:489;-1:-1:-1;;;;;;17074:489:1:o;17568:249::-;17637:6;17690:2;17678:9;17669:7;17665:23;17661:32;17658:52;;;17706:1;17703;17696:12;17658:52;17738:9;17732:16;17757:30;17781:5;17757:30;:::i

Swarm Source

ipfs://18c3d49b5216a8ab962c4f042643d7620e15030873eea967bf15f842055883a8

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