Token

Magic Internet Money Slot Machine (MIMSM)

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

ERC-721

Overview

Max Total Supply

22 MIMSM

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xd9c02d0d699c829425a20d8c77b62f7f8a8e3243

Filtered by Token Holder

0x7754AB999455B8045901fda8f5440d5CF5743fEa

Balance

1 MIMSM

0x7754AB999455B8045901fda8f5440d5CF5743fEa

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

MIMSM

Compiler Version

v0.8.13+commit.abaa5c0e

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

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

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

// File: @openzeppelin/[email protected]/utils/structs/EnumerableSet.sol


// OpenZeppelin Contracts (last updated v4.7.0) (utils/structs/EnumerableSet.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 *  Trying to delete such a structure from storage will likely result in data corruption, rendering the structure unusable.
 *  See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 *  In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// File: IOperatorFilterRegistry.sol


pragma solidity ^0.8.13;


interface IOperatorFilterRegistry {
    function isOperatorAllowed(address registrant, address operator) external returns (bool);
    function register(address registrant) external;
    function registerAndSubscribe(address registrant, address subscription) external;
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;
    function updateOperator(address registrant, address operator, bool filtered) external;
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
    function subscribe(address registrant, address registrantToSubscribe) external;
    function unsubscribe(address registrant, bool copyExistingEntries) external;
    function subscriptionOf(address addr) external returns (address registrant);
    function subscribers(address registrant) external returns (address[] memory);
    function subscriberAt(address registrant, uint256 index) external returns (address);
    function copyEntriesOf(address registrant, address registrantToCopy) external;
    function isOperatorFiltered(address registrant, address operator) external returns (bool);
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
    function filteredOperators(address addr) external returns (address[] memory);
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
    function isRegistered(address addr) external returns (bool);
    function codeHashOf(address addr) external returns (bytes32);
}
// File: OperatorFilterer.sol


pragma solidity ^0.8.13;


contract OperatorFilterer {
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry constant operatorFilterRegistry =
        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);

    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(operatorFilterRegistry).code.length > 0) {
            if (subscribe) {
                operatorFilterRegistry.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    operatorFilterRegistry.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    operatorFilterRegistry.register(address(this));
                }
            }
        }
    }

    modifier onlyAllowedOperator() virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(operatorFilterRegistry).code.length > 0) {
            if (!operatorFilterRegistry.isOperatorAllowed(address(this), msg.sender)) {
                revert OperatorNotAllowed(msg.sender);
            }
        }
        _;
    }
}
// File: DefaultOperatorFilterer.sol


pragma solidity ^0.8.13;


contract DefaultOperatorFilterer is OperatorFilterer {
    address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);

    constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}
// File: @openzeppelin/[email protected]/utils/cryptography/MerkleProof.sol


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

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

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

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

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

    /**
     * @dev Returns true if the `leaves` can be proved to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and the sibling nodes in `proof`,
     * consuming from one or the other at each step according to the instructions given by
     * `proofFlags`.
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/[email protected]/utils/Strings.sol


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

pragma solidity ^0.8.0;

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

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

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

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

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

// File: @openzeppelin/[email protected]/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/[email protected]/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.7.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 anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/[email protected]/utils/Address.sol


// OpenZeppelin Contracts (last updated v4.7.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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/[email protected]/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/[email protected]/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/[email protected]/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/[email protected]/token/ERC721/IERC721.sol


// OpenZeppelin Contracts (last updated v4.7.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: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

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

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

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

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

// File: @openzeppelin/[email protected]/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: ERC721A.sol


// Creator: Chiru Labs

pragma solidity ^0.8.4;








error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
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 1;
    }

    /**
     * @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) {
        return uint256(_addressData[owner].numberMinted);
    }

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

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

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

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

        unchecked {
            if (_startTokenId() <= curr && 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 virtual override {
        if (operator == _msgSender()) revert ApproveToCaller();

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

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

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

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

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

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

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

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

        _beforeTokenTransfers(from, to, tokenId, 1);

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

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

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

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

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

    /**
     * @dev This is equivalent to _burn(tokenId, false)
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

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

        address from = prevOwnership.addr;

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

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

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

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

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

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

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

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

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

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

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

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

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


pragma solidity ^0.8.4;






contract MIMSM is ERC721A, Ownable, DefaultOperatorFilterer {
    using Strings for uint256;

    string public hiddenMetadataURI;
    string public baseURI;
    string public baseExtension = ".json";
    bool public publicSale;
    bool public preSale;
    bool public revealed;
    bytes32 public merkleRoot;
    uint256 public maxPerTx = 50;
    uint256 public maxSupply = 15000;
    uint256 public cost = .009 ether;


    constructor() ERC721A("Magic Internet Money Slot Machine", "MIMSM") {}

    modifier mintCompliance(uint256 quantity) {
        require(quantity > 0, "Quantity must be higher than zero!");
        require(totalSupply() + quantity <= maxSupply, "Max supply reached");
        require(quantity <= maxPerTx, "Limit per tx exceed!");
        require(msg.value >= cost * quantity, "Not enough ether!");
        _;
    }

    modifier verify(bytes32[] calldata _proof) {
        bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
        require(
            MerkleProof.verify(_proof, merkleRoot, leaf),
            "Invalid proof!"
        );
        _;
    }

     // allowlist mint
    function allowlistMint(uint256 quantity, bytes32[] calldata _proof)
        public
        payable
        mintCompliance(quantity)
        verify(_proof)
    {
        require(preSale, "The contract is paused!");
        _safeMint(msg.sender, quantity);
    }

    // public mint
    function mint(uint256 quantity) external payable mintCompliance(quantity) {
        require(publicSale, "The public sale is not enabled!");
        _safeMint(msg.sender, quantity);
    }

    // dev mint
    function devMint(uint256 quantity) external onlyOwner {
        uint256 supply = totalSupply();
        require(quantity > 0, "Quantity must be higher than zero!");
        require(supply + quantity <= maxSupply, "Max supply reached!");
        _safeMint(msg.sender, quantity);
    }

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

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

        if (!revealed) {
            return hiddenMetadataURI;
        }

        string memory currentBaseURI = _baseURI();

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

    function setMaxSupply(uint256 _amount) public onlyOwner {
        maxSupply = _amount;
    }

    function setMaxTx(uint256 _amount) public onlyOwner {
        maxPerTx = _amount;
    }

    function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
        merkleRoot = _merkleRoot;
    }

    function setSale(bool _preSale, bool _publicSale) public onlyOwner {
        preSale = _preSale;
        publicSale = _publicSale;
    }

    function setPrice(uint256 _cost) public onlyOwner {
        cost = _cost;
    }

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

    function setHiddenMetadataURI(string memory _hiddenMetadataURI) public onlyOwner {
        hiddenMetadataURI = _hiddenMetadataURI;
    }

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

    function airdrop(uint256 quantity, address _address) public onlyOwner {
        uint256 supply = totalSupply();
        require(quantity > 0, "Quantity Must Be Higher Than Zero!");
        require(supply + quantity <= maxSupply, "Max Supply Reached!");
        _safeMint(_address, quantity);
    }

    function setBaseExtension(string memory _newBaseExtension)
        public
        onlyOwner
    {
        baseExtension = _newBaseExtension;
    }

    function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator {
        super.transferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator {
        super.safeTransferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
        public
        override
        onlyAllowedOperator
    {
        super.safeTransferFrom(from, to, tokenId, data);
    }

    function withdraw() public onlyOwner {
        uint256 balance = address(this).balance;
        payable(msg.sender).transfer(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":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","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":"uint256","name":"quantity","type":"uint256"},{"internalType":"address","name":"_address","type":"address"}],"name":"airdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"allowlistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"devMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hiddenMetadataURI","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":[],"name":"maxPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"preSale","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSale","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":"_newBaseExtension","type":"string"}],"name":"setBaseExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_hiddenMetadataURI","type":"string"}],"name":"setHiddenMetadataURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"setMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"setMaxTx","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cost","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setReveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_preSale","type":"bool"},{"internalType":"bool","name":"_publicSale","type":"bool"}],"name":"setSale","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":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

71380:4901:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53576:305;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56689:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58192:204;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57755:371;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71779:32;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52825:303;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75567:157;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75005:85;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71673:25;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71591:22;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73041:288;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;76135:143;;;;;;;;;;;;;:::i;:::-;;75732:165;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;74859:138;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71646:20;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74747:104;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71620:19;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56497:125;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71519:21;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74200:94;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53945:206;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;31231:103;;;;;;;;;;;;;:::i;:::-;;72531:268;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;74399:104;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;30583:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74658:81;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56858:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72827:189;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58468:287;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75905:222;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71481:31;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74302:89;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75098:302;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71547:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73470:722;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71740:32;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75408:151;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58826:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74511:139;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;31489:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71705:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53576:305;53678:4;53730:25;53715:40;;;:11;:40;;;;:105;;;;53787:33;53772:48;;;:11;:48;;;;53715:105;:158;;;;53837:36;53861:11;53837:23;:36::i;:::-;53715:158;53695:178;;53576:305;;;:::o;56689:100::-;56743:13;56776:5;56769:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56689:100;:::o;58192:204::-;58260:7;58285:16;58293:7;58285;:16::i;:::-;58280:64;;58310:34;;;;;;;;;;;;;;58280:64;58364:15;:24;58380:7;58364:24;;;;;;;;;;;;;;;;;;;;;58357:31;;58192:204;;;:::o;57755:371::-;57828:13;57844:24;57860:7;57844:15;:24::i;:::-;57828:40;;57889:5;57883:11;;:2;:11;;;57879:48;;57903:24;;;;;;;;;;;;;;57879:48;57960:5;57944:21;;:12;:10;:12::i;:::-;:21;;;;:63;;;;;57970:37;57987:5;57994:12;:10;:12::i;:::-;57970:16;:37::i;:::-;57969:38;57944:63;57940:138;;;58031:35;;;;;;;;;;;;;;57940:138;58090:28;58099:2;58103:7;58112:5;58090:8;:28::i;:::-;57817:309;57755:371;;:::o;71779:32::-;;;;:::o;52825:303::-;52869:7;53094:15;:13;:15::i;:::-;53079:12;;53063:13;;:28;:46;53056:53;;52825:303;:::o;75567:157::-;16712:1;15538:42;16666:43;;;:47;16662:225;;;15538:42;16735:40;;;16784:4;16791:10;16735:67;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16730:146;;16849:10;16830:30;;;;;;;;;;;:::i;:::-;;;;;;;;16730:146;16662:225;75679:37:::1;75698:4;75704:2;75708:7;75679:18;:37::i;:::-;75567:157:::0;;;:::o;75005:85::-;30469:13;:11;:13::i;:::-;75076:6:::1;75065:8;;:17;;;;;;;;;;;;;;;;;;75005:85:::0;:::o;71673:25::-;;;;:::o;71591:22::-;;;;;;;;;;;;;:::o;73041:288::-;30469:13;:11;:13::i;:::-;73106:14:::1;73123:13;:11;:13::i;:::-;73106:30;;73166:1;73155:8;:12;73147:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;73246:9;;73234:8;73225:6;:17;;;;:::i;:::-;:30;;73217:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;73290:31;73300:10;73312:8;73290:9;:31::i;:::-;73095:234;73041:288:::0;:::o;76135:143::-;30469:13;:11;:13::i;:::-;76183:15:::1;76201:21;76183:39;;76241:10;76233:28;;:37;76262:7;76233:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;76172:106;76135:143::o:0;75732:165::-;16712:1;15538:42;16666:43;;;:47;16662:225;;;15538:42;16735:40;;;16784:4;16791:10;16735:67;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16730:146;;16849:10;16830:30;;;;;;;;;;;:::i;:::-;;;;;;;;16730:146;16662:225;75848:41:::1;75871:4;75877:2;75881:7;75848:22;:41::i;:::-;75732:165:::0;;;:::o;74859:138::-;30469:13;:11;:13::i;:::-;74971:18:::1;74951:17;:38;;;;;;;;;;;;:::i;:::-;;74859:138:::0;:::o;71646:20::-;;;;;;;;;;;;;:::o;74747:104::-;30469:13;:11;:13::i;:::-;74832:11:::1;74822:7;:21;;;;;;;;;;;;:::i;:::-;;74747:104:::0;:::o;71620:19::-;;;;;;;;;;;;;:::o;56497:125::-;56561:7;56588:21;56601:7;56588:12;:21::i;:::-;:26;;;56581:33;;56497:125;;;:::o;71519:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;74200:94::-;30469:13;:11;:13::i;:::-;74279:7:::1;74267:9;:19;;;;74200:94:::0;:::o;53945:206::-;54009:7;54050:1;54033:19;;:5;:19;;;54029:60;;54061:28;;;;;;;;;;;;;;54029:60;54115:12;:19;54128:5;54115:19;;;;;;;;;;;;;;;:27;;;;;;;;;;;;54107:36;;54100:43;;53945:206;;;:::o;31231:103::-;30469:13;:11;:13::i;:::-;31296:30:::1;31323:1;31296:18;:30::i;:::-;31231:103::o:0;72531:268::-;72656:8;71972:1;71961:8;:12;71953:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;72059:9;;72047:8;72031:13;:11;:13::i;:::-;:24;;;;:::i;:::-;:37;;72023:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;72122:8;;72110;:20;;72102:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;72194:8;72187:4;;:15;;;;:::i;:::-;72174:9;:28;;72166:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;72682:6:::1;;72306:12;72348:10;72331:28;;;;;;;;:::i;:::-;;;;;;;;;;;;;72321:39;;;;;;72306:54;;72393:44;72412:6;;72393:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72420:10;;72432:4;72393:18;:44::i;:::-;72371:108;;;;;;;;;;;;:::i;:::-;;;;;;;;;72714:7:::2;;;;;;;;;;;72706:43;;;;;;;;;;;;:::i;:::-;;;;;;;;;72760:31;72770:10;72782:8;72760:9;:31::i;:::-;72295:204:::1;72235:1;;72531:268:::0;;;;:::o;74399:104::-;30469:13;:11;:13::i;:::-;74484:11:::1;74471:10;:24;;;;74399:104:::0;:::o;30583:87::-;30629:7;30656:6;;;;;;;;;;;30649:13;;30583:87;:::o;74658:81::-;30469:13;:11;:13::i;:::-;74726:5:::1;74719:4;:12;;;;74658:81:::0;:::o;56858:104::-;56914:13;56947:7;56940:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56858:104;:::o;72827:189::-;72891:8;71972:1;71961:8;:12;71953:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;72059:9;;72047:8;72031:13;:11;:13::i;:::-;:24;;;;:::i;:::-;:37;;72023:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;72122:8;;72110;:20;;72102:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;72194:8;72187:4;;:15;;;;:::i;:::-;72174:9;:28;;72166:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;72920:10:::1;;;;;;;;;;;72912:54;;;;;;;;;;;;:::i;:::-;;;;;;;;;72977:31;72987:10;72999:8;72977:9;:31::i;:::-;72827:189:::0;;:::o;58468:287::-;58579:12;:10;:12::i;:::-;58567:24;;:8;:24;;;58563:54;;58600:17;;;;;;;;;;;;;;58563:54;58675:8;58630:18;:32;58649:12;:10;:12::i;:::-;58630:32;;;;;;;;;;;;;;;:42;58663:8;58630:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;58728:8;58699:48;;58714:12;:10;:12::i;:::-;58699:48;;;58738:8;58699:48;;;;;;:::i;:::-;;;;;;;;58468:287;;:::o;75905:222::-;16712:1;15538:42;16666:43;;;:47;16662:225;;;15538:42;16735:40;;;16784:4;16791:10;16735:67;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16730:146;;16849:10;16830:30;;;;;;;;;;;:::i;:::-;;;;;;;;16730:146;16662:225;76072:47:::1;76095:4;76101:2;76105:7;76114:4;76072:22;:47::i;:::-;75905:222:::0;;;;:::o;71481:31::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;74302:89::-;30469:13;:11;:13::i;:::-;74376:7:::1;74365:8;:18;;;;74302:89:::0;:::o;75098:302::-;30469:13;:11;:13::i;:::-;75179:14:::1;75196:13;:11;:13::i;:::-;75179:30;;75239:1;75228:8;:12;75220:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;75319:9;;75307:8;75298:6;:17;;;;:::i;:::-;:30;;75290:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;75363:29;75373:8;75383;75363:9;:29::i;:::-;75168:232;75098:302:::0;;:::o;71547:37::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;73470:722::-;73588:13;73641:16;73649:7;73641;:16::i;:::-;73619:113;;;;;;;;;;;;:::i;:::-;;;;;;;;;73750:8;;;;;;;;;;;73745:66;;73782:17;73775:24;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73745:66;73823:28;73854:10;:8;:10::i;:::-;73823:41;;73928:1;73903:14;73897:28;:32;:287;;;;;;;;;;;;;;;;;74021:14;74062:18;:7;:16;:18::i;:::-;74107:13;73978:165;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;73897:287;73877:307;;;73470:722;;;;:::o;71740:32::-;;;;:::o;75408:151::-;30469:13;:11;:13::i;:::-;75534:17:::1;75518:13;:33;;;;;;;;;;;;:::i;:::-;;75408:151:::0;:::o;58826:164::-;58923:4;58947:18;:25;58966:5;58947:25;;;;;;;;;;;;;;;:35;58973:8;58947:35;;;;;;;;;;;;;;;;;;;;;;;;;58940:42;;58826:164;;;;:::o;74511:139::-;30469:13;:11;:13::i;:::-;74599:8:::1;74589:7;;:18;;;;;;;;;;;;;;;;;;74631:11;74618:10;;:24;;;;;;;;;;;;;;;;;;74511:139:::0;;:::o;31489:201::-;30469:13;:11;:13::i;:::-;31598:1:::1;31578:22;;:8;:22;;::::0;31570:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;31654:28;31673:8;31654:18;:28::i;:::-;31489:201:::0;:::o;71705:28::-;;;;:::o;43461:157::-;43546:4;43585:25;43570:40;;;:11;:40;;;;43563:47;;43461:157;;;:::o;60178:174::-;60235:4;60278:7;60259:15;:13;:15::i;:::-;:26;;:53;;;;;60299:13;;60289:7;:23;60259:53;:85;;;;;60317:11;:20;60329:7;60317:20;;;;;;;;;;;:27;;;;;;;;;;;;60316:28;60259:85;60252:92;;60178:174;;;:::o;29128:98::-;29181:7;29208:10;29201:17;;29128:98;:::o;68335:196::-;68477:2;68450:15;:24;68466:7;68450:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;68515:7;68511:2;68495:28;;68504:5;68495:28;;;;;;;;;;;;68335:196;;;:::o;52599:92::-;52655:7;52682:1;52675:8;;52599:92;:::o;59057:170::-;59191:28;59201:4;59207:2;59211:7;59191:9;:28::i;:::-;59057:170;;;:::o;30748:132::-;30823:12;:10;:12::i;:::-;30812:23;;:7;:5;:7::i;:::-;:23;;;30804:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;30748:132::o;60360:104::-;60429:27;60439:2;60443:8;60429:27;;;;;;;;;;;;:9;:27::i;:::-;60360:104;;:::o;59298:185::-;59436:39;59453:4;59459:2;59463:7;59436:39;;;;;;;;;;;;:16;:39::i;:::-;59298:185;;;:::o;55326:1109::-;55388:21;;:::i;:::-;55422:12;55437:7;55422:22;;55505:4;55486:15;:13;:15::i;:::-;:23;;:47;;;;;55520:13;;55513:4;:20;55486:47;55482:886;;;55554:31;55588:11;:17;55600:4;55588:17;;;;;;;;;;;55554:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55629:9;:16;;;55624:729;;55700:1;55674:28;;:9;:14;;;:28;;;55670:101;;55738:9;55731:16;;;;;;55670:101;56073:261;56080:4;56073:261;;;56113:6;;;;;;;;56158:11;:17;56170:4;56158:17;;;;;;;;;;;56146:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56232:1;56206:28;;:9;:14;;;:28;;;56202:109;;56274:9;56267:16;;;;;;56202:109;56073:261;;;55624:729;55535:833;55482:886;56396:31;;;;;;;;;;;;;;55326:1109;;;;:::o;31850:191::-;31924:16;31943:6;;;;;;;;;;;31924:25;;31969:8;31960:6;;:17;;;;;;;;;;;;;;;;;;32024:8;31993:40;;32014:8;31993:40;;;;;;;;;;;;31913:128;31850:191;:::o;18434:190::-;18559:4;18612;18583:25;18596:5;18603:4;18583:12;:25::i;:::-;:33;18576:40;;18434:190;;;;;:::o;59554:369::-;59721:28;59731:4;59737:2;59741:7;59721:9;:28::i;:::-;59764:15;:2;:13;;;:15::i;:::-;:76;;;;;59784:56;59815:4;59821:2;59825:7;59834:5;59784:30;:56::i;:::-;59783:57;59764:76;59760:156;;;59864:40;;;;;;;;;;;;;;59760:156;59554:369;;;;:::o;73354:108::-;73414:13;73447:7;73440:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73354:108;:::o;26376:723::-;26432:13;26662:1;26653:5;:10;26649:53;;26680:10;;;;;;;;;;;;;;;;;;;;;26649:53;26712:12;26727:5;26712:20;;26743:14;26768:78;26783:1;26775:4;:9;26768:78;;26801:8;;;;;:::i;:::-;;;;26832:2;26824:10;;;;;:::i;:::-;;;26768:78;;;26856:19;26888:6;26878:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26856:39;;26906:154;26922:1;26913:5;:10;26906:154;;26950:1;26940:11;;;;;:::i;:::-;;;27017:2;27009:5;:10;;;;:::i;:::-;26996:2;:24;;;;:::i;:::-;26983:39;;26966:6;26973;26966:14;;;;;;;;:::i;:::-;;;;;:56;;;;;;;;;;;27046:2;27037:11;;;;;:::i;:::-;;;26906:154;;;27084:6;27070:21;;;;;26376:723;;;;:::o;63278:2130::-;63393:35;63431:21;63444:7;63431:12;:21::i;:::-;63393:59;;63491:4;63469:26;;:13;:18;;;:26;;;63465:67;;63504:28;;;;;;;;;;;;;;63465:67;63545:22;63587:4;63571:20;;:12;:10;:12::i;:::-;:20;;;:73;;;;63608:36;63625:4;63631:12;:10;:12::i;:::-;63608:16;:36::i;:::-;63571:73;:126;;;;63685:12;:10;:12::i;:::-;63661:36;;:20;63673:7;63661:11;:20::i;:::-;:36;;;63571:126;63545:153;;63716:17;63711:66;;63742:35;;;;;;;;;;;;;;63711:66;63806:1;63792:16;;:2;:16;;;63788:52;;63817:23;;;;;;;;;;;;;;63788:52;63853:43;63875:4;63881:2;63885:7;63894:1;63853:21;:43::i;:::-;63961:35;63978:1;63982:7;63991:4;63961:8;:35::i;:::-;64322:1;64292:12;:18;64305:4;64292:18;;;;;;;;;;;;;;;:26;;;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64366:1;64338:12;:16;64351:2;64338:16;;;;;;;;;;;;;;;:24;;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64384:31;64418:11;:20;64430:7;64418:20;;;;;;;;;;;64384:54;;64469:2;64453:8;:13;;;:18;;;;;;;;;;;;;;;;;;64519:15;64486:8;:23;;;:49;;;;;;;;;;;;;;;;;;64787:19;64819:1;64809:7;:11;64787:33;;64835:31;64869:11;:24;64881:11;64869:24;;;;;;;;;;;64835:58;;64937:1;64912:27;;:8;:13;;;;;;;;;;;;:27;;;64908:384;;65122:13;;65107:11;:28;65103:174;;65176:4;65160:8;:13;;;:20;;;;;;;;;;;;;;;;;;65229:13;:28;;;65203:8;:23;;;:54;;;;;;;;;;;;;;;;;;65103:174;64908:384;64267:1036;;;65339:7;65335:2;65320:27;;65329:4;65320:27;;;;;;;;;;;;65358:42;65379:4;65385:2;65389:7;65398:1;65358:20;:42::i;:::-;63382:2026;;63278:2130;;;:::o;60827:163::-;60950:32;60956:2;60960:8;60970:5;60977:4;60950:5;:32::i;:::-;60827:163;;;:::o;19301:296::-;19384:7;19404:20;19427:4;19404:27;;19447:9;19442:118;19466:5;:12;19462:1;:16;19442:118;;;19515:33;19525:12;19539:5;19545:1;19539:8;;;;;;;;:::i;:::-;;;;;;;;19515:9;:33::i;:::-;19500:48;;19480:3;;;;;:::i;:::-;;;;19442:118;;;;19577:12;19570:19;;;19301:296;;;;:::o;33287:326::-;33347:4;33604:1;33582:7;:19;;;:23;33575:30;;33287:326;;;:::o;69023:667::-;69186:4;69223:2;69207:36;;;69244:12;:10;:12::i;:::-;69258:4;69264:7;69273:5;69207:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;69203:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69458:1;69441:6;:13;:18;69437:235;;69487:40;;;;;;;;;;;;;;69437:235;69630:6;69624:13;69615:6;69611:2;69607:15;69600:38;69203:480;69336:45;;;69326:55;;;:6;:55;;;;69319:62;;;69023:667;;;;;;:::o;70338:159::-;;;;;:::o;71156:158::-;;;;;:::o;61249:1775::-;61388:20;61411:13;;61388:36;;61453:1;61439:16;;:2;:16;;;61435:48;;61464:19;;;;;;;;;;;;;;61435:48;61510:1;61498:8;:13;61494:44;;61520:18;;;;;;;;;;;;;;61494:44;61551:61;61581:1;61585:2;61589:12;61603:8;61551:21;:61::i;:::-;61924:8;61889:12;:16;61902:2;61889:16;;;;;;;;;;;;;;;:24;;;:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61988:8;61948:12;:16;61961:2;61948:16;;;;;;;;;;;;;;;:29;;;:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62047:2;62014:11;:25;62026:12;62014:25;;;;;;;;;;;:30;;;:35;;;;;;;;;;;;;;;;;;62114:15;62064:11;:25;62076:12;62064:25;;;;;;;;;;;:40;;;:66;;;;;;;;;;;;;;;;;;62147:20;62170:12;62147:35;;62197:11;62226:8;62211:12;:23;62197:37;;62255:4;:23;;;;;62263:15;:2;:13;;;:15::i;:::-;62255:23;62251:641;;;62299:314;62355:12;62351:2;62330:38;;62347:1;62330:38;;;;;;;;;;;;62396:69;62435:1;62439:2;62443:14;;;;;;62459:5;62396:30;:69::i;:::-;62391:174;;62501:40;;;;;;;;;;;;;;62391:174;62608:3;62592:12;:19;62299:314;;62694:12;62677:13;;:29;62673:43;;62708:8;;;62673:43;62251:641;;;62757:120;62813:14;;;;;;62809:2;62788:40;;62805:1;62788:40;;;;;;;;;;;;62872:3;62856:12;:19;62757:120;;62251:641;62922:12;62906:13;:28;;;;61864:1082;;62956:60;62985:1;62989:2;62993:12;63007:8;62956:20;:60::i;:::-;61377:1647;61249:1775;;;;:::o;25508:149::-;25571:7;25602:1;25598;:5;:51;;25629:20;25644:1;25647;25629:14;:20::i;:::-;25598:51;;;25606:20;25621:1;25624;25606:14;:20::i;:::-;25598:51;25591:58;;25508:149;;;;:::o;25665:268::-;25733:13;25840:1;25834:4;25827:15;25869:1;25863:4;25856:15;25910:4;25904;25894:21;25885:30;;25665:268;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:307::-;1866:1;1876:113;1890:6;1887:1;1884:13;1876:113;;;1975:1;1970:3;1966:11;1960:18;1956:1;1951:3;1947:11;1940:39;1912:2;1909:1;1905:10;1900:15;;1876:113;;;2007:6;2004:1;2001:13;1998:101;;;2087:1;2078:6;2073:3;2069:16;2062:27;1998:101;1847:258;1798:307;;;:::o;2111:102::-;2152:6;2203:2;2199:7;2194:2;2187:5;2183:14;2179:28;2169:38;;2111:102;;;:::o;2219:364::-;2307:3;2335:39;2368:5;2335:39;:::i;:::-;2390:71;2454:6;2449:3;2390:71;:::i;:::-;2383:78;;2470:52;2515:6;2510:3;2503:4;2496:5;2492:16;2470:52;:::i;:::-;2547:29;2569:6;2547:29;:::i;:::-;2542:3;2538:39;2531:46;;2311:272;2219:364;;;;:::o;2589:313::-;2702:4;2740:2;2729:9;2725:18;2717:26;;2789:9;2783:4;2779:20;2775:1;2764:9;2760:17;2753:47;2817:78;2890:4;2881:6;2817:78;:::i;:::-;2809:86;;2589:313;;;;:::o;2908:77::-;2945:7;2974:5;2963:16;;2908:77;;;:::o;2991:122::-;3064:24;3082:5;3064:24;:::i;:::-;3057:5;3054:35;3044:63;;3103:1;3100;3093:12;3044:63;2991:122;:::o;3119:139::-;3165:5;3203:6;3190:20;3181:29;;3219:33;3246:5;3219:33;:::i;:::-;3119:139;;;;:::o;3264:329::-;3323:6;3372:2;3360:9;3351:7;3347:23;3343:32;3340:119;;;3378:79;;:::i;:::-;3340:119;3498:1;3523:53;3568:7;3559:6;3548:9;3544:22;3523:53;:::i;:::-;3513:63;;3469:117;3264:329;;;;:::o;3599:126::-;3636:7;3676:42;3669:5;3665:54;3654:65;;3599:126;;;:::o;3731:96::-;3768:7;3797:24;3815:5;3797:24;:::i;:::-;3786:35;;3731:96;;;:::o;3833:118::-;3920:24;3938:5;3920:24;:::i;:::-;3915:3;3908:37;3833:118;;:::o;3957:222::-;4050:4;4088:2;4077:9;4073:18;4065:26;;4101:71;4169:1;4158:9;4154:17;4145:6;4101:71;:::i;:::-;3957:222;;;;:::o;4185:122::-;4258:24;4276:5;4258:24;:::i;:::-;4251:5;4248:35;4238:63;;4297:1;4294;4287:12;4238:63;4185:122;:::o;4313:139::-;4359:5;4397:6;4384:20;4375:29;;4413:33;4440:5;4413:33;:::i;:::-;4313:139;;;;:::o;4458:474::-;4526:6;4534;4583:2;4571:9;4562:7;4558:23;4554:32;4551:119;;;4589:79;;:::i;:::-;4551:119;4709:1;4734:53;4779:7;4770:6;4759:9;4755:22;4734:53;:::i;:::-;4724:63;;4680:117;4836:2;4862:53;4907:7;4898:6;4887:9;4883:22;4862:53;:::i;:::-;4852:63;;4807:118;4458:474;;;;;:::o;4938:118::-;5025:24;5043:5;5025:24;:::i;:::-;5020:3;5013:37;4938:118;;:::o;5062:222::-;5155:4;5193:2;5182:9;5178:18;5170:26;;5206:71;5274:1;5263:9;5259:17;5250:6;5206:71;:::i;:::-;5062:222;;;;:::o;5290:619::-;5367:6;5375;5383;5432:2;5420:9;5411:7;5407:23;5403:32;5400:119;;;5438:79;;:::i;:::-;5400:119;5558:1;5583:53;5628:7;5619:6;5608:9;5604:22;5583:53;:::i;:::-;5573:63;;5529:117;5685:2;5711:53;5756:7;5747:6;5736:9;5732:22;5711:53;:::i;:::-;5701:63;;5656:118;5813:2;5839:53;5884:7;5875:6;5864:9;5860:22;5839:53;:::i;:::-;5829:63;;5784:118;5290:619;;;;;:::o;5915:116::-;5985:21;6000:5;5985:21;:::i;:::-;5978:5;5975:32;5965:60;;6021:1;6018;6011:12;5965:60;5915:116;:::o;6037:133::-;6080:5;6118:6;6105:20;6096:29;;6134:30;6158:5;6134:30;:::i;:::-;6037:133;;;;:::o;6176:323::-;6232:6;6281:2;6269:9;6260:7;6256:23;6252:32;6249:119;;;6287:79;;:::i;:::-;6249:119;6407:1;6432:50;6474:7;6465:6;6454:9;6450:22;6432:50;:::i;:::-;6422:60;;6378:114;6176:323;;;;:::o;6505:77::-;6542:7;6571:5;6560:16;;6505:77;;;:::o;6588:118::-;6675:24;6693:5;6675:24;:::i;:::-;6670:3;6663:37;6588:118;;:::o;6712:222::-;6805:4;6843:2;6832:9;6828:18;6820:26;;6856:71;6924:1;6913:9;6909:17;6900:6;6856:71;:::i;:::-;6712:222;;;;:::o;6940:117::-;7049:1;7046;7039:12;7063:117;7172:1;7169;7162:12;7186:180;7234:77;7231:1;7224:88;7331:4;7328:1;7321:15;7355:4;7352:1;7345:15;7372:281;7455:27;7477:4;7455:27;:::i;:::-;7447:6;7443:40;7585:6;7573:10;7570:22;7549:18;7537:10;7534:34;7531:62;7528:88;;;7596:18;;:::i;:::-;7528:88;7636:10;7632:2;7625:22;7415:238;7372:281;;:::o;7659:129::-;7693:6;7720:20;;:::i;:::-;7710:30;;7749:33;7777:4;7769:6;7749:33;:::i;:::-;7659:129;;;:::o;7794:308::-;7856:4;7946:18;7938:6;7935:30;7932:56;;;7968:18;;:::i;:::-;7932:56;8006:29;8028:6;8006:29;:::i;:::-;7998:37;;8090:4;8084;8080:15;8072:23;;7794:308;;;:::o;8108:154::-;8192:6;8187:3;8182;8169:30;8254:1;8245:6;8240:3;8236:16;8229:27;8108:154;;;:::o;8268:412::-;8346:5;8371:66;8387:49;8429:6;8387:49;:::i;:::-;8371:66;:::i;:::-;8362:75;;8460:6;8453:5;8446:21;8498:4;8491:5;8487:16;8536:3;8527:6;8522:3;8518:16;8515:25;8512:112;;;8543:79;;:::i;:::-;8512:112;8633:41;8667:6;8662:3;8657;8633:41;:::i;:::-;8352:328;8268:412;;;;;:::o;8700:340::-;8756:5;8805:3;8798:4;8790:6;8786:17;8782:27;8772:122;;8813:79;;:::i;:::-;8772:122;8930:6;8917:20;8955:79;9030:3;9022:6;9015:4;9007:6;9003:17;8955:79;:::i;:::-;8946:88;;8762:278;8700:340;;;;:::o;9046:509::-;9115:6;9164:2;9152:9;9143:7;9139:23;9135:32;9132:119;;;9170:79;;:::i;:::-;9132:119;9318:1;9307:9;9303:17;9290:31;9348:18;9340:6;9337:30;9334:117;;;9370:79;;:::i;:::-;9334:117;9475:63;9530:7;9521:6;9510:9;9506:22;9475:63;:::i;:::-;9465:73;;9261:287;9046:509;;;;:::o;9561:329::-;9620:6;9669:2;9657:9;9648:7;9644:23;9640:32;9637:119;;;9675:79;;:::i;:::-;9637:119;9795:1;9820:53;9865:7;9856:6;9845:9;9841:22;9820:53;:::i;:::-;9810:63;;9766:117;9561:329;;;;:::o;9896:117::-;10005:1;10002;9995:12;10019:117;10128:1;10125;10118:12;10159:568;10232:8;10242:6;10292:3;10285:4;10277:6;10273:17;10269:27;10259:122;;10300:79;;:::i;:::-;10259:122;10413:6;10400:20;10390:30;;10443:18;10435:6;10432:30;10429:117;;;10465:79;;:::i;:::-;10429:117;10579:4;10571:6;10567:17;10555:29;;10633:3;10625:4;10617:6;10613:17;10603:8;10599:32;10596:41;10593:128;;;10640:79;;:::i;:::-;10593:128;10159:568;;;;;:::o;10733:704::-;10828:6;10836;10844;10893:2;10881:9;10872:7;10868:23;10864:32;10861:119;;;10899:79;;:::i;:::-;10861:119;11019:1;11044:53;11089:7;11080:6;11069:9;11065:22;11044:53;:::i;:::-;11034:63;;10990:117;11174:2;11163:9;11159:18;11146:32;11205:18;11197:6;11194:30;11191:117;;;11227:79;;:::i;:::-;11191:117;11340:80;11412:7;11403:6;11392:9;11388:22;11340:80;:::i;:::-;11322:98;;;;11117:313;10733:704;;;;;:::o;11443:122::-;11516:24;11534:5;11516:24;:::i;:::-;11509:5;11506:35;11496:63;;11555:1;11552;11545:12;11496:63;11443:122;:::o;11571:139::-;11617:5;11655:6;11642:20;11633:29;;11671:33;11698:5;11671:33;:::i;:::-;11571:139;;;;:::o;11716:329::-;11775:6;11824:2;11812:9;11803:7;11799:23;11795:32;11792:119;;;11830:79;;:::i;:::-;11792:119;11950:1;11975:53;12020:7;12011:6;12000:9;11996:22;11975:53;:::i;:::-;11965:63;;11921:117;11716:329;;;;:::o;12051:468::-;12116:6;12124;12173:2;12161:9;12152:7;12148:23;12144:32;12141:119;;;12179:79;;:::i;:::-;12141:119;12299:1;12324:53;12369:7;12360:6;12349:9;12345:22;12324:53;:::i;:::-;12314:63;;12270:117;12426:2;12452:50;12494:7;12485:6;12474:9;12470:22;12452:50;:::i;:::-;12442:60;;12397:115;12051:468;;;;;:::o;12525:307::-;12586:4;12676:18;12668:6;12665:30;12662:56;;;12698:18;;:::i;:::-;12662:56;12736:29;12758:6;12736:29;:::i;:::-;12728:37;;12820:4;12814;12810:15;12802:23;;12525:307;;;:::o;12838:410::-;12915:5;12940:65;12956:48;12997:6;12956:48;:::i;:::-;12940:65;:::i;:::-;12931:74;;13028:6;13021:5;13014:21;13066:4;13059:5;13055:16;13104:3;13095:6;13090:3;13086:16;13083:25;13080:112;;;13111:79;;:::i;:::-;13080:112;13201:41;13235:6;13230:3;13225;13201:41;:::i;:::-;12921:327;12838:410;;;;;:::o;13267:338::-;13322:5;13371:3;13364:4;13356:6;13352:17;13348:27;13338:122;;13379:79;;:::i;:::-;13338:122;13496:6;13483:20;13521:78;13595:3;13587:6;13580:4;13572:6;13568:17;13521:78;:::i;:::-;13512:87;;13328:277;13267:338;;;;:::o;13611:943::-;13706:6;13714;13722;13730;13779:3;13767:9;13758:7;13754:23;13750:33;13747:120;;;13786:79;;:::i;:::-;13747:120;13906:1;13931:53;13976:7;13967:6;13956:9;13952:22;13931:53;:::i;:::-;13921:63;;13877:117;14033:2;14059:53;14104:7;14095:6;14084:9;14080:22;14059:53;:::i;:::-;14049:63;;14004:118;14161:2;14187:53;14232:7;14223:6;14212:9;14208:22;14187:53;:::i;:::-;14177:63;;14132:118;14317:2;14306:9;14302:18;14289:32;14348:18;14340:6;14337:30;14334:117;;;14370:79;;:::i;:::-;14334:117;14475:62;14529:7;14520:6;14509:9;14505:22;14475:62;:::i;:::-;14465:72;;14260:287;13611:943;;;;;;;:::o;14560:474::-;14628:6;14636;14685:2;14673:9;14664:7;14660:23;14656:32;14653:119;;;14691:79;;:::i;:::-;14653:119;14811:1;14836:53;14881:7;14872:6;14861:9;14857:22;14836:53;:::i;:::-;14826:63;;14782:117;14938:2;14964:53;15009:7;15000:6;14989:9;14985:22;14964:53;:::i;:::-;14954:63;;14909:118;14560:474;;;;;:::o;15040:::-;15108:6;15116;15165:2;15153:9;15144:7;15140:23;15136:32;15133:119;;;15171:79;;:::i;:::-;15133:119;15291:1;15316:53;15361:7;15352:6;15341:9;15337:22;15316:53;:::i;:::-;15306:63;;15262:117;15418:2;15444:53;15489:7;15480:6;15469:9;15465:22;15444:53;:::i;:::-;15434:63;;15389:118;15040:474;;;;;:::o;15520:462::-;15582:6;15590;15639:2;15627:9;15618:7;15614:23;15610:32;15607:119;;;15645:79;;:::i;:::-;15607:119;15765:1;15790:50;15832:7;15823:6;15812:9;15808:22;15790:50;:::i;:::-;15780:60;;15736:114;15889:2;15915:50;15957:7;15948:6;15937:9;15933:22;15915:50;:::i;:::-;15905:60;;15860:115;15520:462;;;;;:::o;15988:180::-;16036:77;16033:1;16026:88;16133:4;16130:1;16123:15;16157:4;16154:1;16147:15;16174:320;16218:6;16255:1;16249:4;16245:12;16235:22;;16302:1;16296:4;16292:12;16323:18;16313:81;;16379:4;16371:6;16367:17;16357:27;;16313:81;16441:2;16433:6;16430:14;16410:18;16407:38;16404:84;;16460:18;;:::i;:::-;16404:84;16225:269;16174:320;;;:::o;16500:332::-;16621:4;16659:2;16648:9;16644:18;16636:26;;16672:71;16740:1;16729:9;16725:17;16716:6;16672:71;:::i;:::-;16753:72;16821:2;16810:9;16806:18;16797:6;16753:72;:::i;:::-;16500:332;;;;;:::o;16838:137::-;16892:5;16923:6;16917:13;16908:22;;16939:30;16963:5;16939:30;:::i;:::-;16838:137;;;;:::o;16981:345::-;17048:6;17097:2;17085:9;17076:7;17072:23;17068:32;17065:119;;;17103:79;;:::i;:::-;17065:119;17223:1;17248:61;17301:7;17292:6;17281:9;17277:22;17248:61;:::i;:::-;17238:71;;17194:125;16981:345;;;;:::o;17332:221::-;17472:34;17468:1;17460:6;17456:14;17449:58;17541:4;17536:2;17528:6;17524:15;17517:29;17332:221;:::o;17559:366::-;17701:3;17722:67;17786:2;17781:3;17722:67;:::i;:::-;17715:74;;17798:93;17887:3;17798:93;:::i;:::-;17916:2;17911:3;17907:12;17900:19;;17559:366;;;:::o;17931:419::-;18097:4;18135:2;18124:9;18120:18;18112:26;;18184:9;18178:4;18174:20;18170:1;18159:9;18155:17;18148:47;18212:131;18338:4;18212:131;:::i;:::-;18204:139;;17931:419;;;:::o;18356:180::-;18404:77;18401:1;18394:88;18501:4;18498:1;18491:15;18525:4;18522:1;18515:15;18542:305;18582:3;18601:20;18619:1;18601:20;:::i;:::-;18596:25;;18635:20;18653:1;18635:20;:::i;:::-;18630:25;;18789:1;18721:66;18717:74;18714:1;18711:81;18708:107;;;18795:18;;:::i;:::-;18708:107;18839:1;18836;18832:9;18825:16;;18542:305;;;;:::o;18853:169::-;18993:21;18989:1;18981:6;18977:14;18970:45;18853:169;:::o;19028:366::-;19170:3;19191:67;19255:2;19250:3;19191:67;:::i;:::-;19184:74;;19267:93;19356:3;19267:93;:::i;:::-;19385:2;19380:3;19376:12;19369:19;;19028:366;;;:::o;19400:419::-;19566:4;19604:2;19593:9;19589:18;19581:26;;19653:9;19647:4;19643:20;19639:1;19628:9;19624:17;19617:47;19681:131;19807:4;19681:131;:::i;:::-;19673:139;;19400:419;;;:::o;19825:168::-;19965:20;19961:1;19953:6;19949:14;19942:44;19825:168;:::o;19999:366::-;20141:3;20162:67;20226:2;20221:3;20162:67;:::i;:::-;20155:74;;20238:93;20327:3;20238:93;:::i;:::-;20356:2;20351:3;20347:12;20340:19;;19999:366;;;:::o;20371:419::-;20537:4;20575:2;20564:9;20560:18;20552:26;;20624:9;20618:4;20614:20;20610:1;20599:9;20595:17;20588:47;20652:131;20778:4;20652:131;:::i;:::-;20644:139;;20371:419;;;:::o;20796:170::-;20936:22;20932:1;20924:6;20920:14;20913:46;20796:170;:::o;20972:366::-;21114:3;21135:67;21199:2;21194:3;21135:67;:::i;:::-;21128:74;;21211:93;21300:3;21211:93;:::i;:::-;21329:2;21324:3;21320:12;21313:19;;20972:366;;;:::o;21344:419::-;21510:4;21548:2;21537:9;21533:18;21525:26;;21597:9;21591:4;21587:20;21583:1;21572:9;21568:17;21561:47;21625:131;21751:4;21625:131;:::i;:::-;21617:139;;21344:419;;;:::o;21769:348::-;21809:7;21832:20;21850:1;21832:20;:::i;:::-;21827:25;;21866:20;21884:1;21866:20;:::i;:::-;21861:25;;22054:1;21986:66;21982:74;21979:1;21976:81;21971:1;21964:9;21957:17;21953:105;21950:131;;;22061:18;;:::i;:::-;21950:131;22109:1;22106;22102:9;22091:20;;21769:348;;;;:::o;22123:167::-;22263:19;22259:1;22251:6;22247:14;22240:43;22123:167;:::o;22296:366::-;22438:3;22459:67;22523:2;22518:3;22459:67;:::i;:::-;22452:74;;22535:93;22624:3;22535:93;:::i;:::-;22653:2;22648:3;22644:12;22637:19;;22296:366;;;:::o;22668:419::-;22834:4;22872:2;22861:9;22857:18;22849:26;;22921:9;22915:4;22911:20;22907:1;22896:9;22892:17;22885:47;22949:131;23075:4;22949:131;:::i;:::-;22941:139;;22668:419;;;:::o;23093:94::-;23126:8;23174:5;23170:2;23166:14;23145:35;;23093:94;;;:::o;23193:::-;23232:7;23261:20;23275:5;23261:20;:::i;:::-;23250:31;;23193:94;;;:::o;23293:100::-;23332:7;23361:26;23381:5;23361:26;:::i;:::-;23350:37;;23293:100;;;:::o;23399:157::-;23504:45;23524:24;23542:5;23524:24;:::i;:::-;23504:45;:::i;:::-;23499:3;23492:58;23399:157;;:::o;23562:256::-;23674:3;23689:75;23760:3;23751:6;23689:75;:::i;:::-;23789:2;23784:3;23780:12;23773:19;;23809:3;23802:10;;23562:256;;;;:::o;23824:164::-;23964:16;23960:1;23952:6;23948:14;23941:40;23824:164;:::o;23994:366::-;24136:3;24157:67;24221:2;24216:3;24157:67;:::i;:::-;24150:74;;24233:93;24322:3;24233:93;:::i;:::-;24351:2;24346:3;24342:12;24335:19;;23994:366;;;:::o;24366:419::-;24532:4;24570:2;24559:9;24555:18;24547:26;;24619:9;24613:4;24609:20;24605:1;24594:9;24590:17;24583:47;24647:131;24773:4;24647:131;:::i;:::-;24639:139;;24366:419;;;:::o;24791:173::-;24931:25;24927:1;24919:6;24915:14;24908:49;24791:173;:::o;24970:366::-;25112:3;25133:67;25197:2;25192:3;25133:67;:::i;:::-;25126:74;;25209:93;25298:3;25209:93;:::i;:::-;25327:2;25322:3;25318:12;25311:19;;24970:366;;;:::o;25342:419::-;25508:4;25546:2;25535:9;25531:18;25523:26;;25595:9;25589:4;25585:20;25581:1;25570:9;25566:17;25559:47;25623:131;25749:4;25623:131;:::i;:::-;25615:139;;25342:419;;;:::o;25767:181::-;25907:33;25903:1;25895:6;25891:14;25884:57;25767:181;:::o;25954:366::-;26096:3;26117:67;26181:2;26176:3;26117:67;:::i;:::-;26110:74;;26193:93;26282:3;26193:93;:::i;:::-;26311:2;26306:3;26302:12;26295:19;;25954:366;;;:::o;26326:419::-;26492:4;26530:2;26519:9;26515:18;26507:26;;26579:9;26573:4;26569:20;26565:1;26554:9;26550:17;26543:47;26607:131;26733:4;26607:131;:::i;:::-;26599:139;;26326:419;;;:::o;26751:221::-;26891:34;26887:1;26879:6;26875:14;26868:58;26960:4;26955:2;26947:6;26943:15;26936:29;26751:221;:::o;26978:366::-;27120:3;27141:67;27205:2;27200:3;27141:67;:::i;:::-;27134:74;;27217:93;27306:3;27217:93;:::i;:::-;27335:2;27330:3;27326:12;27319:19;;26978:366;;;:::o;27350:419::-;27516:4;27554:2;27543:9;27539:18;27531:26;;27603:9;27597:4;27593:20;27589:1;27578:9;27574:17;27567:47;27631:131;27757:4;27631:131;:::i;:::-;27623:139;;27350:419;;;:::o;27775:169::-;27915:21;27911:1;27903:6;27899:14;27892:45;27775:169;:::o;27950:366::-;28092:3;28113:67;28177:2;28172:3;28113:67;:::i;:::-;28106:74;;28189:93;28278:3;28189:93;:::i;:::-;28307:2;28302:3;28298:12;28291:19;;27950:366;;;:::o;28322:419::-;28488:4;28526:2;28515:9;28511:18;28503:26;;28575:9;28569:4;28565:20;28561:1;28550:9;28546:17;28539:47;28603:131;28729:4;28603:131;:::i;:::-;28595:139;;28322:419;;;:::o;28747:234::-;28887:34;28883:1;28875:6;28871:14;28864:58;28956:17;28951:2;28943:6;28939:15;28932:42;28747:234;:::o;28987:366::-;29129:3;29150:67;29214:2;29209:3;29150:67;:::i;:::-;29143:74;;29226:93;29315:3;29226:93;:::i;:::-;29344:2;29339:3;29335:12;29328:19;;28987:366;;;:::o;29359:419::-;29525:4;29563:2;29552:9;29548:18;29540:26;;29612:9;29606:4;29602:20;29598:1;29587:9;29583:17;29576:47;29640:131;29766:4;29640:131;:::i;:::-;29632:139;;29359:419;;;:::o;29784:148::-;29886:11;29923:3;29908:18;;29784:148;;;;:::o;29938:377::-;30044:3;30072:39;30105:5;30072:39;:::i;:::-;30127:89;30209:6;30204:3;30127:89;:::i;:::-;30120:96;;30225:52;30270:6;30265:3;30258:4;30251:5;30247:16;30225:52;:::i;:::-;30302:6;30297:3;30293:16;30286:23;;30048:267;29938:377;;;;:::o;30321:141::-;30370:4;30393:3;30385:11;;30416:3;30413:1;30406:14;30450:4;30447:1;30437:18;30429:26;;30321:141;;;:::o;30492:845::-;30595:3;30632:5;30626:12;30661:36;30687:9;30661:36;:::i;:::-;30713:89;30795:6;30790:3;30713:89;:::i;:::-;30706:96;;30833:1;30822:9;30818:17;30849:1;30844:137;;;;30995:1;30990:341;;;;30811:520;;30844:137;30928:4;30924:9;30913;30909:25;30904:3;30897:38;30964:6;30959:3;30955:16;30948:23;;30844:137;;30990:341;31057:38;31089:5;31057:38;:::i;:::-;31117:1;31131:154;31145:6;31142:1;31139:13;31131:154;;;31219:7;31213:14;31209:1;31204:3;31200:11;31193:35;31269:1;31260:7;31256:15;31245:26;;31167:4;31164:1;31160:12;31155:17;;31131:154;;;31314:6;31309:3;31305:16;31298:23;;30997:334;;30811:520;;30599:738;;30492:845;;;;:::o;31343:589::-;31568:3;31590:95;31681:3;31672:6;31590:95;:::i;:::-;31583:102;;31702:95;31793:3;31784:6;31702:95;:::i;:::-;31695:102;;31814:92;31902:3;31893:6;31814:92;:::i;:::-;31807:99;;31923:3;31916:10;;31343:589;;;;;;:::o;31938:225::-;32078:34;32074:1;32066:6;32062:14;32055:58;32147:8;32142:2;32134:6;32130:15;32123:33;31938:225;:::o;32169:366::-;32311:3;32332:67;32396:2;32391:3;32332:67;:::i;:::-;32325:74;;32408:93;32497:3;32408:93;:::i;:::-;32526:2;32521:3;32517:12;32510:19;;32169:366;;;:::o;32541:419::-;32707:4;32745:2;32734:9;32730:18;32722:26;;32794:9;32788:4;32784:20;32780:1;32769:9;32765:17;32758:47;32822:131;32948:4;32822:131;:::i;:::-;32814:139;;32541:419;;;:::o;32966:182::-;33106:34;33102:1;33094:6;33090:14;33083:58;32966:182;:::o;33154:366::-;33296:3;33317:67;33381:2;33376:3;33317:67;:::i;:::-;33310:74;;33393:93;33482:3;33393:93;:::i;:::-;33511:2;33506:3;33502:12;33495:19;;33154:366;;;:::o;33526:419::-;33692:4;33730:2;33719:9;33715:18;33707:26;;33779:9;33773:4;33769:20;33765:1;33754:9;33750:17;33743:47;33807:131;33933:4;33807:131;:::i;:::-;33799:139;;33526:419;;;:::o;33951:233::-;33990:3;34013:24;34031:5;34013:24;:::i;:::-;34004:33;;34059:66;34052:5;34049:77;34046:103;;34129:18;;:::i;:::-;34046:103;34176:1;34169:5;34165:13;34158:20;;33951:233;;;:::o;34190:180::-;34238:77;34235:1;34228:88;34335:4;34332:1;34325:15;34359:4;34356:1;34349:15;34376:185;34416:1;34433:20;34451:1;34433:20;:::i;:::-;34428:25;;34467:20;34485:1;34467:20;:::i;:::-;34462:25;;34506:1;34496:35;;34511:18;;:::i;:::-;34496:35;34553:1;34550;34546:9;34541:14;;34376:185;;;;:::o;34567:191::-;34607:4;34627:20;34645:1;34627:20;:::i;:::-;34622:25;;34661:20;34679:1;34661:20;:::i;:::-;34656:25;;34700:1;34697;34694:8;34691:34;;;34705:18;;:::i;:::-;34691:34;34750:1;34747;34743:9;34735:17;;34567:191;;;;:::o;34764:176::-;34796:1;34813:20;34831:1;34813:20;:::i;:::-;34808:25;;34847:20;34865:1;34847:20;:::i;:::-;34842:25;;34886:1;34876:35;;34891:18;;:::i;:::-;34876:35;34932:1;34929;34925:9;34920:14;;34764:176;;;;:::o;34946:180::-;34994:77;34991:1;34984:88;35091:4;35088:1;35081:15;35115:4;35112:1;35105:15;35132:98;35183:6;35217:5;35211:12;35201:22;;35132:98;;;:::o;35236:168::-;35319:11;35353:6;35348:3;35341:19;35393:4;35388:3;35384:14;35369:29;;35236:168;;;;:::o;35410:360::-;35496:3;35524:38;35556:5;35524:38;:::i;:::-;35578:70;35641:6;35636:3;35578:70;:::i;:::-;35571:77;;35657:52;35702:6;35697:3;35690:4;35683:5;35679:16;35657:52;:::i;:::-;35734:29;35756:6;35734:29;:::i;:::-;35729:3;35725:39;35718:46;;35500:270;35410:360;;;;:::o;35776:640::-;35971:4;36009:3;35998:9;35994:19;35986:27;;36023:71;36091:1;36080:9;36076:17;36067:6;36023:71;:::i;:::-;36104:72;36172:2;36161:9;36157:18;36148:6;36104:72;:::i;:::-;36186;36254:2;36243:9;36239:18;36230:6;36186:72;:::i;:::-;36305:9;36299:4;36295:20;36290:2;36279:9;36275:18;36268:48;36333:76;36404:4;36395:6;36333:76;:::i;:::-;36325:84;;35776:640;;;;;;;:::o;36422:141::-;36478:5;36509:6;36503:13;36494:22;;36525:32;36551:5;36525:32;:::i;:::-;36422:141;;;;:::o;36569:349::-;36638:6;36687:2;36675:9;36666:7;36662:23;36658:32;36655:119;;;36693:79;;:::i;:::-;36655:119;36813:1;36838:63;36893:7;36884:6;36873:9;36869:22;36838:63;:::i;:::-;36828:73;;36784:127;36569:349;;;;:::o

Swarm Source

ipfs://bd2abc33a1bfa875686f5967a432e9fa877120b179ea2f54abd193837d3e8018

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