Token

Daily Psychos (DP)

ERC-721

Overview

Max Total Supply

6,969 DP

Holders

908

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xa2abf3474be8dd25e40ff10a339354bda083e892

Filtered by Token Holder

0xB53D9Bd2A9985D822887456A0Bf7eCA899768FCA

Balance

10 DP

0xb53d9bd2a9985d822887456a0bf7eca899768fca

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Compiler Version

v0.8.0+commit.c7dfd78e

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-06-09
*/

// File: .workspaces/nft_workspace/contracts/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

// File: .workspaces/nft_workspace/contracts/contracts/utils/math/SafeMath.sol


// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File: .workspaces/nft_workspace/contracts/contracts/utils/Base64.sol


// OpenZeppelin Contracts (last updated v4.5.0) (utils/Base64.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides a set of functions to operate with Base64 strings.
 *
 * _Available since v4.5._
 */
library Base64 {
    /**
     * @dev Base64 Encoding/Decoding Table
     */
    string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    /**
     * @dev Converts a `bytes` to its Bytes64 `string` representation.
     */
    function encode(bytes memory data) internal pure returns (string memory) {
        /**
         * Inspired by Brecht Devos (Brechtpd) implementation - MIT licence
         * https://github.com/Brechtpd/base64/blob/e78d9fd951e7b0977ddca77d92dc85183770daf4/base64.sol
         */
        if (data.length == 0) return "";

        // Loads the table into memory
        string memory table = _TABLE;

        // Encoding takes 3 bytes chunks of binary data from `bytes` data parameter
        // and split into 4 numbers of 6 bits.
        // The final Base64 length should be `bytes` data length multiplied by 4/3 rounded up
        // - `data.length + 2`  -> Round up
        // - `/ 3`              -> Number of 3-bytes chunks
        // - `4 *`              -> 4 characters for each chunk
        string memory result = new string(4 * ((data.length + 2) / 3));

        assembly {
            // Prepare the lookup table (skip the first "length" byte)
            let tablePtr := add(table, 1)

            // Prepare result pointer, jump over length
            let resultPtr := add(result, 32)

            // Run over the input, 3 bytes at a time
            for {
                let dataPtr := data
                let endPtr := add(data, mload(data))
            } lt(dataPtr, endPtr) {

            } {
                // Advance 3 bytes
                dataPtr := add(dataPtr, 3)
                let input := mload(dataPtr)

                // To write each character, shift the 3 bytes (18 bits) chunk
                // 4 times in blocks of 6 bits for each character (18, 12, 6, 0)
                // and apply logical AND with 0x3F which is the number of
                // the previous character in the ASCII table prior to the Base64 Table
                // The result is then added to the table to get the character to write,
                // and finally write it in the result pointer but with a left shift
                // of 256 (1 byte) - 8 (1 ASCII char) = 248 bits

                mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(shr(6, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(input, 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance
            }

            // When data `bytes` is not exactly 3 bytes long
            // it is padded with `=` characters at the end
            switch mod(mload(data), 3)
            case 1 {
                mstore8(sub(resultPtr, 1), 0x3d)
                mstore8(sub(resultPtr, 2), 0x3d)
            }
            case 2 {
                mstore8(sub(resultPtr, 1), 0x3d)
            }
        }

        return result;
    }
}

// File: .workspaces/nft_workspace/contracts/contracts/utils/Counters.sol


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

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// File: .workspaces/nft_workspace/contracts/contracts/utils/Strings.sol


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

pragma solidity ^0.8.0;

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

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

// File: .workspaces/nft_workspace/contracts/contracts/utils/cryptography/ECDSA.sol


// OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;


/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

// File: .workspaces/nft_workspace/contracts/contracts/utils/Context.sol


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

pragma solidity ^0.8.0;

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

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

// File: .workspaces/nft_workspace/contracts/contracts/access/Ownable.sol


// OpenZeppelin Contracts v4.4.1 (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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        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: .workspaces/nft_workspace/contracts/contracts/utils/Address.sol


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

pragma solidity ^0.8.0;

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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: .workspaces/nft_workspace/contracts/contracts/token/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts v4.4.1 (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: .workspaces/nft_workspace/contracts/contracts/utils/introspection/IERC165.sol


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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: .workspaces/nft_workspace/contracts/contracts/utils/introspection/ERC165.sol


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

pragma solidity ^0.8.0;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// File: .workspaces/nft_workspace/contracts/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts v4.4.1 (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`, 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 be 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 Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

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

// File: .workspaces/nft_workspace/contracts/contracts/token/ERC721/extensions/IERC721Enumerable.sol


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

pragma solidity ^0.8.0;


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

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

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

// File: .workspaces/nft_workspace/contracts/contracts/token/ERC721/extensions/IERC721Metadata.sol


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

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// File: .workspaces/nft_workspace/src/ERC721A.sol



pragma solidity ^0.8.0;









/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
 *
 * Assumes the number of issuable tokens (collection size) is capped and fits in a uint128.
 *
 * Does not support burning tokens to address(0).
 */
contract ERC721A is
    Context,
    ERC165,
    IERC721,
    IERC721Metadata,
    IERC721Enumerable
{
    using Address for address;
    using Strings for uint256;

    struct TokenOwnership {
        address addr;
        uint64 startTimestamp;
    }

    struct AddressData {
        uint128 balance;
        uint128 numberMinted;
    }

    uint256 private currentIndex = 0;

    uint256 internal immutable collectionSize;
    uint256 internal immutable maxBatchSize;

    // 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) private _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;

    /**
     * @dev
     * `maxBatchSize` refers to how much a minter can mint at a time.
     * `collectionSize_` refers to how many tokens are in the collection.
     */
    constructor(
        string memory name_,
        string memory symbol_,
        uint256 maxBatchSize_,
        uint256 collectionSize_
    ) {
        require(
            collectionSize_ > 0,
            "ERC721A: collection must have a nonzero supply"
        );
        require(maxBatchSize_ > 0, "ERC721A: max batch size must be nonzero");
        _name = name_;
        _symbol = symbol_;
        maxBatchSize = maxBatchSize_;
        collectionSize = collectionSize_;
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return currentIndex;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index)
        public
        view
        override
        returns (uint256)
    {
        require(index < totalSupply(), "ERC721A: global index out of bounds");
        return index;
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     * This read function is O(collectionSize). If calling from a separate contract, be sure to test gas first.
     * It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index)
        public
        view
        override
        returns (uint256)
    {
        require(index < balanceOf(owner), "ERC721A: owner index out of bounds");
        uint256 numMintedSoFar = totalSupply();
        uint256 tokenIdsIdx = 0;
        address currOwnershipAddr = address(0);
        for (uint256 i = 0; i < numMintedSoFar; i++) {
            TokenOwnership memory ownership = _ownerships[i];
            if (ownership.addr != address(0)) {
                currOwnershipAddr = ownership.addr;
            }
            if (currOwnershipAddr == owner) {
                if (tokenIdsIdx == index) {
                    return i;
                }
                tokenIdsIdx++;
            }
        }
        revert("ERC721A: unable to get token of owner by index");
    }

    /**
     * @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 ||
            interfaceId == type(IERC721Enumerable).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view override returns (uint256) {
        require(
            owner != address(0),
            "ERC721A: balance query for the zero address"
        );
        return uint256(_addressData[owner].balance);
    }

    function _numberMinted(address owner) internal view returns (uint256) {
        require(
            owner != address(0),
            "ERC721A: number minted query for the zero address"
        );
        return uint256(_addressData[owner].numberMinted);
    }

    function ownershipOf(uint256 tokenId)
        internal
        view
        returns (TokenOwnership memory)
    {
        require(_exists(tokenId), "ERC721A: owner query for nonexistent token");

        uint256 lowestTokenToCheck;
        if (tokenId >= maxBatchSize) {
            lowestTokenToCheck = tokenId - maxBatchSize + 1;
        }

        for (uint256 curr = tokenId; curr >= lowestTokenToCheck; curr--) {
            TokenOwnership memory ownership = _ownerships[curr];
            if (ownership.addr != address(0)) {
                return ownership;
            }
        }

        revert("ERC721A: unable to determine the owner of token");
    }

    /**
     * @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)
    {
        require(
            _exists(tokenId),
            "ERC721Metadata: URI query for nonexistent token"
        );

        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);
        require(to != owner, "ERC721A: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721A: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId, owner);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId)
        public
        view
        override
        returns (address)
    {
        require(
            _exists(tokenId),
            "ERC721A: approved query for nonexistent token"
        );

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved)
        public
        override
    {
        require(operator != _msgSender(), "ERC721A: approve to caller");

        _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 override {
        _transfer(from, to, tokenId);
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public override {
        _transfer(from, to, tokenId);
        require(
            _checkOnERC721Received(from, to, tokenId, _data),
            "ERC721A: transfer to non ERC721Receiver implementer"
        );
    }

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

    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, "");
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - there must be `quantity` tokens remaining unminted in the total collection.
     * - `to` cannot be the zero address.
     * - `quantity` cannot be larger than the max batch size.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        uint256 startTokenId = currentIndex;
        require(to != address(0), "ERC721A: mint to the zero address");
        // We know if the first token in the batch doesn't exist, the other ones don't as well, because of serial ordering.
        require(!_exists(startTokenId), "ERC721A: token already minted");
        require(quantity <= maxBatchSize, "ERC721A: quantity to mint too high");

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

        AddressData memory addressData = _addressData[to];
        _addressData[to] = AddressData(
            addressData.balance + uint128(quantity),
            addressData.numberMinted + uint128(quantity)
        );
        _ownerships[startTokenId] = TokenOwnership(to, uint64(block.timestamp));

        uint256 updatedIndex = startTokenId;

        for (uint256 i = 0; i < quantity; i++) {
            emit Transfer(address(0), to, updatedIndex);
            require(
                _checkOnERC721Received(address(0), to, updatedIndex, _data),
                "ERC721A: transfer to non ERC721Receiver implementer"
            );
            updatedIndex++;
        }

        currentIndex = updatedIndex;
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) private {
        TokenOwnership memory prevOwnership = ownershipOf(tokenId);

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

        require(
            isApprovedOrOwner,
            "ERC721A: transfer caller is not owner nor approved"
        );

        require(
            prevOwnership.addr == from,
            "ERC721A: transfer from incorrect owner"
        );
        require(to != address(0), "ERC721A: transfer to the zero address");

        _beforeTokenTransfers(from, to, tokenId, 1);

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

        _addressData[from].balance -= 1;
        _addressData[to].balance += 1;
        _ownerships[tokenId] = TokenOwnership(to, uint64(block.timestamp));

        // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
        // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
        uint256 nextTokenId = tokenId + 1;
        if (_ownerships[nextTokenId].addr == address(0)) {
            if (_exists(nextTokenId)) {
                _ownerships[nextTokenId] = TokenOwnership(
                    prevOwnership.addr,
                    prevOwnership.startTimestamp
                );
            }
        }

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

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

    uint256 public nextOwnerToExplicitlySet = 0;

    /**
     * @dev Explicitly set `owners` to eliminate loops in future calls of ownerOf().
     */
    function _setOwnersExplicit(uint256 quantity) internal {
        uint256 oldNextOwnerToSet = nextOwnerToExplicitlySet;
        require(quantity > 0, "quantity must be nonzero");
        uint256 endIndex = oldNextOwnerToSet + quantity - 1;
        if (endIndex > collectionSize - 1) {
            endIndex = collectionSize - 1;
        }
        // We know if the last one in the group exists, all in the group exist, due to serial ordering.
        require(_exists(endIndex), "not enough minted yet for this cleanup");
        for (uint256 i = oldNextOwnerToSet; i <= endIndex; i++) {
            if (_ownerships[i].addr == address(0)) {
                TokenOwnership memory ownership = ownershipOf(i);
                _ownerships[i] = TokenOwnership(
                    ownership.addr,
                    ownership.startTimestamp
                );
            }
        }
        nextOwnerToExplicitlySet = endIndex + 1;
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a 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 _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            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(
                        "ERC721A: transfer to non ERC721Receiver implementer"
                    );
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     *
     * 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`.
     */
    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.
     *
     * 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` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}
// File: .workspaces/nft_workspace/contracts/contracts/token/ERC721/ERC721.sol


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

pragma solidity ^0.8.0;








/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

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

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @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 virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

    /**
     * @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) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        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 overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_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 {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _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 {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @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.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @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`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);

        _afterTokenTransfer(address(0), to, tokenId);
    }

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

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);

        _afterTokenTransfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * 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
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

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

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a 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 _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * 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, ``from``'s `tokenId` will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

// File: .workspaces/nft_workspace/contracts/contracts/token/ERC721/extensions/ERC721Enumerable.sol


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

pragma solidity ^0.8.0;



/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
        return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * 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, ``from``'s `tokenId` will be burned.
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, tokenId);

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}

// File: .workspaces/nft_workspace/contracts/contracts/token/ERC721/extensions/ERC721Burnable.sol


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

pragma solidity ^0.8.0;



/**
 * @title ERC721 Burnable Token
 * @dev ERC721 Token that can be irreversibly burned (destroyed).
 */
abstract contract ERC721Burnable is Context, ERC721 {
    /**
     * @dev Burns `tokenId`. See {ERC721-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721Burnable: caller is not owner nor approved");
        _burn(tokenId);
    }
}

// File: .workspaces/nft_workspace/src/dailypsychos721a.sol



pragma solidity >=0.8.0 <0.9.0;











contract DP is ERC721A, Ownable, ReentrancyGuard {
    using Strings for uint256;
    using Counters for Counters.Counter;

    uint public constant MAX_SUPPLY = 6969;
    uint public PRICE = 0.02 ether;
    uint public constant MAX_PER_MINT = 10;
    uint public constant totalFree = 1000;
    mapping(address => uint256) private _mintedFreeAmount;
    uint public maxPerFree  = 2;



    string public baseTokenURI;
     constructor() ERC721A("Daily Psychos", "DP",10,6969) {
     }


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



    function setBaseURI(string memory _baseTokenURI) public onlyOwner {
        baseTokenURI = _baseTokenURI;
    }


    function mint(uint _count) public payable {
        uint256 cost = PRICE;
        bool isFree = ((totalSupply() + _count < totalFree + 1) &&
            (_mintedFreeAmount[msg.sender] + _count <= maxPerFree));

        if (isFree) {
            cost = 0;
            _mintedFreeAmount[msg.sender] += _count;
        }
        uint totalMinted = totalSupply();
        
        require(totalMinted + _count <= MAX_SUPPLY, "Not enough NFT left!");
        require(_count >0 && _count <= MAX_PER_MINT, "Cannot mint specified number of NFT.");
        require(msg.value >= cost * _count, "Not enough ether to purchase NFT.");
         _safeMint(msg.sender, _count);
           
    }

      function setPrice(uint256 price_) public onlyOwner {
        PRICE = price_;
    }
        function getPrice() public onlyOwner view   returns (uint ){
      return PRICE;
        }

     function fund(uint256 price) private {
        require(msg.value >= price, "DP: Need to send more ETH.");
        if (msg.value > price) {
             payable(msg.sender).transfer(price);
        }
    }

   

    function tokensOfOwner(address _owner) external view returns (uint[] memory) {

        uint tokenCount = balanceOf(_owner);
        uint[] memory tokensId = new uint256[](tokenCount);

        for (uint i = 0; i < tokenCount; i++) {
            tokensId[i] = tokenOfOwnerByIndex(_owner, i);
        }
        return tokensId;
    }

    function withdraw() public payable onlyOwner {
        require(msg.sender == owner(),"no permission to withdraw.");
        uint balance = address(this).balance;
        require(balance > 0, "No ether left to withdraw");

        (bool success, ) = (msg.sender).call{value: balance}("");
        require(success, "Transfer failed.");
    }


    function getBaseURI() public onlyOwner view  returns (string memory){
      return _baseURI();
        }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"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":[],"name":"MAX_PER_MINT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBaseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"maxPerFree","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_count","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextOwnerToExplicitlySet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseTokenURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"price_","type":"uint256"}],"name":"setPrice","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":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFree","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

89221:2695:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52641:422;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54602:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56297:292;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55818:413;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;89435:38;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50997:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57324:162;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51705:864;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;89353:38;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;89480:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;91451:346;;;:::i;:::-;;57557:177;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51174:228;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;89855:113;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54411:124;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53127:258;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;91807:106;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;29297:103;;;;;;;;;;;;;:::i;:::-;;91102:341;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;89398:30;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;28646:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;90683:84;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54771:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;90777:92;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;89978:695;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56661:311;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57805:355;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;89584:27;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54946:468;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;89624:26;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62686:43;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57043:214;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;29555:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52641:422;52788:4;52845:25;52830:40;;;:11;:40;;;;:105;;;;52902:33;52887:48;;;:11;:48;;;;52830:105;:172;;;;52967:35;52952:50;;;:11;:50;;;;52830:172;:225;;;;53019:36;53043:11;53019:23;:36::i;:::-;52830:225;52810:245;;52641:422;;;:::o;54602:100::-;54656:13;54689:5;54682:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54602:100;:::o;56297:292::-;56401:7;56448:16;56456:7;56448;:16::i;:::-;56426:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;56557:15;:24;56573:7;56557:24;;;;;;;;;;;;;;;;;;;;;56550:31;;56297:292;;;:::o;55818:413::-;55891:13;55907:24;55923:7;55907:15;:24::i;:::-;55891:40;;55956:5;55950:11;;:2;:11;;;;55942:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;56051:5;56035:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;56060:37;56077:5;56084:12;:10;:12::i;:::-;56060:16;:37::i;:::-;56035:62;56013:169;;;;;;;;;;;;:::i;:::-;;;;;;;;;56195:28;56204:2;56208:7;56217:5;56195:8;:28::i;:::-;55818:413;;;:::o;89435:38::-;89471:2;89435:38;:::o;50997:100::-;51050:7;51077:12;;51070:19;;50997:100;:::o;57324:162::-;57450:28;57460:4;57466:2;57470:7;57450:9;:28::i;:::-;57324:162;;;:::o;51705:864::-;51830:7;51871:16;51881:5;51871:9;:16::i;:::-;51863:5;:24;51855:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;51937:22;51962:13;:11;:13::i;:::-;51937:38;;51986:19;52020:25;52074:9;52069:426;52093:14;52089:1;:18;52069:426;;;52129:31;52163:11;:14;52175:1;52163:14;;;;;;;;;;;52129:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52222:1;52196:28;;:9;:14;;;:28;;;52192:103;;52265:9;:14;;;52245:34;;52192:103;52334:5;52313:26;;:17;:26;;;52309:175;;;52379:5;52364:11;:20;52360:77;;;52416:1;52409:8;;;;;;;;;52360:77;52455:13;;;;;:::i;:::-;;;;52309:175;52069:426;52109:3;;;;;:::i;:::-;;;;52069:426;;;;52505:56;;;;;;;;;;:::i;:::-;;;;;;;;51705:864;;;;;:::o;89353:38::-;89387:4;89353:38;:::o;89480:37::-;89513:4;89480:37;:::o;91451:346::-;28877:12;:10;:12::i;:::-;28866:23;;:7;:5;:7::i;:::-;:23;;;28858:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;91529:7:::1;:5;:7::i;:::-;91515:21;;:10;:21;;;91507:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;91577:12;91592:21;91577:36;;91642:1;91632:7;:11;91624:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;91687:12;91706:10;91705:17;;91730:7;91705:37;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;91686:56;;;91761:7;91753:36;;;;;;;;;;;;:::i;:::-;;;;;;;;;28937:1;;91451:346::o:0;57557:177::-;57687:39;57704:4;57710:2;57714:7;57687:39;;;;;;;;;;;;:16;:39::i;:::-;57557:177;;;:::o;51174:228::-;51277:7;51318:13;:11;:13::i;:::-;51310:5;:21;51302:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;51389:5;51382:12;;51174:228;;;:::o;89855:113::-;28877:12;:10;:12::i;:::-;28866:23;;:7;:5;:7::i;:::-;:23;;;28858:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;89947:13:::1;89932:12;:28;;;;;;;;;;;;:::i;:::-;;89855:113:::0;:::o;54411:124::-;54475:7;54502:20;54514:7;54502:11;:20::i;:::-;:25;;;54495:32;;54411:124;;;:::o;53127:258::-;53191:7;53250:1;53233:19;;:5;:19;;;;53211:112;;;;;;;;;;;;:::i;:::-;;;;;;;;;53349:12;:19;53362:5;53349:19;;;;;;;;;;;;;;;:27;;;;;;;;;;;;53341:36;;53334:43;;53127:258;;;:::o;91807:106::-;91861:13;28877:12;:10;:12::i;:::-;28866:23;;:7;:5;:7::i;:::-;:23;;;28858:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;91891:10:::1;:8;:10::i;:::-;91884:17;;91807:106:::0;:::o;29297:103::-;28877:12;:10;:12::i;:::-;28866:23;;:7;:5;:7::i;:::-;:23;;;28858:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;29362:30:::1;29389:1;29362:18;:30::i;:::-;29297:103::o:0;91102:341::-;91164:13;91192:15;91210:17;91220:6;91210:9;:17::i;:::-;91192:35;;91238:22;91277:10;91263:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;91238:50;;91306:6;91301:109;91322:10;91318:1;:14;91301:109;;;91368:30;91388:6;91396:1;91368:19;:30::i;:::-;91354:8;91363:1;91354:11;;;;;;;;;;;;;;;;;;;;;:44;;;;;91334:3;;;;;:::i;:::-;;;;91301:109;;;;91427:8;91420:15;;;;91102:341;;;:::o;89398:30::-;;;;:::o;28646:87::-;28692:7;28719:6;;;;;;;;;;;28712:13;;28646:87;:::o;90683:84::-;28877:12;:10;:12::i;:::-;28866:23;;:7;:5;:7::i;:::-;:23;;;28858:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;90753:6:::1;90745:5;:14;;;;90683:84:::0;:::o;54771:104::-;54827:13;54860:7;54853:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54771:104;:::o;90777:92::-;90830:4;28877:12;:10;:12::i;:::-;28866:23;;:7;:5;:7::i;:::-;:23;;;28858:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;90852:5:::1;;90845:12;;90777:92:::0;:::o;89978:695::-;90031:12;90046:5;;90031:20;;90062:11;90115:1;89513:4;90103:13;;;;:::i;:::-;90094:6;90078:13;:11;:13::i;:::-;:22;;;;:::i;:::-;:38;90077:111;;;;;90177:10;;90167:6;90135:17;:29;90153:10;90135:29;;;;;;;;;;;;;;;;:38;;;;:::i;:::-;:52;;90077:111;90062:127;;90206:6;90202:101;;;90236:1;90229:8;;90285:6;90252:17;:29;90270:10;90252:29;;;;;;;;;;;;;;;;:39;;;;;;;:::i;:::-;;;;;;;;90202:101;90313:16;90332:13;:11;:13::i;:::-;90313:32;;89387:4;90388:6;90374:11;:20;;;;:::i;:::-;:34;;90366:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;90460:1;90452:6;:9;:35;;;;;89471:2;90465:6;:22;;90452:35;90444:84;;;;;;;;;;;;:::i;:::-;;;;;;;;;90567:6;90560:4;:13;;;;:::i;:::-;90547:9;:26;;90539:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;90623:29;90633:10;90645:6;90623:9;:29::i;:::-;89978:695;;;;:::o;56661:311::-;56791:12;:10;:12::i;:::-;56779:24;;:8;:24;;;;56771:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;56892:8;56847:18;:32;56866:12;:10;:12::i;:::-;56847:32;;;;;;;;;;;;;;;:42;56880:8;56847:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;56945:8;56916:48;;56931:12;:10;:12::i;:::-;56916:48;;;56955:8;56916:48;;;;;;:::i;:::-;;;;;;;;56661:311;;:::o;57805:355::-;57964:28;57974:4;57980:2;57984:7;57964:9;:28::i;:::-;58025:48;58048:4;58054:2;58058:7;58067:5;58025:22;:48::i;:::-;58003:149;;;;;;;;;;;;:::i;:::-;;;;;;;;;57805:355;;;;:::o;89584:27::-;;;;:::o;54946:468::-;55064:13;55117:16;55125:7;55117;:16::i;:::-;55095:113;;;;;;;;;;;;:::i;:::-;;;;;;;;;55221:21;55245:10;:8;:10::i;:::-;55221:34;;55310:1;55292:7;55286:21;:25;:120;;;;;;;;;;;;;;;;;55355:7;55364:18;:7;:16;:18::i;:::-;55338:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;55286:120;55266:140;;;54946:468;;;:::o;89624:26::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;62686:43::-;;;;:::o;57043:214::-;57185:4;57214:18;:25;57233:5;57214:25;;;;;;;;;;;;;;;:35;57240:8;57214:35;;;;;;;;;;;;;;;;;;;;;;;;;57207:42;;57043:214;;;;:::o;29555:201::-;28877:12;:10;:12::i;:::-;28866:23;;:7;:5;:7::i;:::-;:23;;;28858:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;29664:1:::1;29644:22;;:8;:22;;;;29636:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;29720:28;29739:8;29720:18;:28::i;:::-;29555:201:::0;:::o;41526:157::-;41611:4;41650:25;41635:40;;;:11;:40;;;;41628:47;;41526:157;;;:::o;58415:111::-;58472:4;58506:12;;58496:7;:22;58489:29;;58415:111;;;:::o;27348:98::-;27401:7;27428:10;27421:17;;27348:98;:::o;62482:196::-;62624:2;62597:15;:24;62613:7;62597:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;62662:7;62658:2;62642:28;;62651:5;62642:28;;;;;;;;;;;;62482:196;;;:::o;60655:1709::-;60770:35;60808:20;60820:7;60808:11;:20::i;:::-;60770:58;;60841:22;60883:13;:18;;;60867:34;;:12;:10;:12::i;:::-;:34;;;:87;;;;60942:12;:10;:12::i;:::-;60918:36;;:20;60930:7;60918:11;:20::i;:::-;:36;;;60867:87;:154;;;;60971:50;60988:13;:18;;;61008:12;:10;:12::i;:::-;60971:16;:50::i;:::-;60867:154;60841:181;;61057:17;61035:117;;;;;;;;;;;;:::i;:::-;;;;;;;;;61209:4;61187:26;;:13;:18;;;:26;;;61165:114;;;;;;;;;;;;:::i;:::-;;;;;;;;;61312:1;61298:16;;:2;:16;;;;61290:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;61369:43;61391:4;61397:2;61401:7;61410:1;61369:21;:43::i;:::-;61477:49;61494:1;61498:7;61507:13;:18;;;61477:8;:49::i;:::-;61569:1;61539:12;:18;61552:4;61539:18;;;;;;;;;;;;;;;:26;;;:31;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;61609:1;61581:12;:16;61594:2;61581:16;;;;;;;;;;;;;;;:24;;;:29;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;61644:43;;;;;;;;61659:2;61644:43;;;;;;61670:15;61644:43;;;;;61621:11;:20;61633:7;61621:20;;;;;;;;;;;:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61927:19;61959:1;61949:7;:11;;;;:::i;:::-;61927:33;;62016:1;61975:43;;:11;:24;61987:11;61975:24;;;;;;;;;;;:29;;;;;;;;;;;;:43;;;61971:288;;;62039:20;62047:11;62039:7;:20::i;:::-;62035:213;;;62107:125;;;;;;;;62144:13;:18;;;62107:125;;;;;;62185:13;:28;;;62107:125;;;;;62080:11;:24;62092:11;62080:24;;;;;;;;;;;:152;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62035:213;61971:288;62295:7;62291:2;62276:27;;62285:4;62276:27;;;;;;;;;;;;62314:42;62335:4;62341:2;62345:7;62354:1;62314:20;:42::i;:::-;60655:1709;;;;;;:::o;53667:682::-;53755:21;;:::i;:::-;53802:16;53810:7;53802;:16::i;:::-;53794:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;53878:26;53930:12;53919:7;:23;53915:103;;54005:1;53990:12;53980:7;:22;;;;:::i;:::-;:26;;;;:::i;:::-;53959:47;;53915:103;54035:12;54050:7;54035:22;;54030:242;54067:18;54059:4;:26;54030:242;;54110:31;54144:11;:17;54156:4;54144:17;;;;;;;;;;;54110:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54206:1;54180:28;;:9;:14;;;:28;;;54176:85;;54236:9;54229:16;;;;;;;54176:85;54030:242;54087:6;;;;;:::i;:::-;;;;54030:242;;;;54284:57;;;;;;;;;;:::i;:::-;;;;;;;;53667:682;;;;:::o;89730:113::-;89790:13;89823:12;89816:19;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;89730:113;:::o;29916:191::-;29990:16;30009:6;;;;;;;;;;;29990:25;;30035:8;30026:6;;:17;;;;;;;;;;;;;;;;;;30090:8;30059:40;;30080:8;30059:40;;;;;;;;;;;;29916:191;;:::o;58534:104::-;58603:27;58613:2;58617:8;58603:27;;;;;;;;;;;;:9;:27::i;:::-;58534:104;;:::o;64357:985::-;64512:4;64533:15;:2;:13;;;:15::i;:::-;64529:806;;;64602:2;64586:36;;;64645:12;:10;:12::i;:::-;64680:4;64707:7;64737:5;64586:175;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;64565:715;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64965:1;64948:6;:13;:18;64944:321;;;64991:109;;;;;;;;;;:::i;:::-;;;;;;;;64944:321;65215:6;65209:13;65200:6;65196:2;65192:15;65185:38;64565:715;64835:45;;;64825:55;;;:6;:55;;;;64818:62;;;;;64529:806;65319:4;65312:11;;64357:985;;;;;;;:::o;15332:723::-;15388:13;15618:1;15609:5;:10;15605:53;;;15636:10;;;;;;;;;;;;;;;;;;;;;15605:53;15668:12;15683:5;15668:20;;15699:14;15724:78;15739:1;15731:4;:9;15724:78;;15757:8;;;;;:::i;:::-;;;;15788:2;15780:10;;;;;:::i;:::-;;;15724:78;;;15812:19;15844:6;15834:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15812:39;;15862:154;15878:1;15869:5;:10;15862:154;;15906:1;15896:11;;;;;:::i;:::-;;;15973:2;15965:5;:10;;;;:::i;:::-;15952:2;:24;;;;:::i;:::-;15939:39;;15922:6;15929;15922:14;;;;;;;;;;;;;;;;;;;:56;;;;;;;;;;;16002:2;15993:11;;;;;:::i;:::-;;;15862:154;;;16040:6;16026:21;;;;;15332:723;;;;:::o;65830:159::-;;;;;:::o;66401:158::-;;;;;:::o;59001:1400::-;59124:20;59147:12;;59124:35;;59192:1;59178:16;;:2;:16;;;;59170:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;59377:21;59385:12;59377:7;:21::i;:::-;59376:22;59368:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;59463:12;59451:8;:24;;59443:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;59527:61;59557:1;59561:2;59565:12;59579:8;59527:21;:61::i;:::-;59601:30;59634:12;:16;59647:2;59634:16;;;;;;;;;;;;;;;59601:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59680:135;;;;;;;;59736:8;59706:11;:19;;;:39;;;;:::i;:::-;59680:135;;;;;;59795:8;59760:11;:24;;;:44;;;;:::i;:::-;59680:135;;;;;59661:12;:16;59674:2;59661:16;;;;;;;;;;;;;;;:154;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59854:43;;;;;;;;59869:2;59854:43;;;;;;59880:15;59854:43;;;;;59826:11;:25;59838:12;59826:25;;;;;;;;;;;:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59910:20;59933:12;59910:35;;59963:9;59958:325;59982:8;59978:1;:12;59958:325;;;60042:12;60038:2;60017:38;;60034:1;60017:38;;;;;;;;;;;;60096:59;60127:1;60131:2;60135:12;60149:5;60096:22;:59::i;:::-;60070:172;;;;;;;;;;;;:::i;:::-;;;;;;;;;60257:14;;;;;:::i;:::-;;;;59992:3;;;;;:::i;:::-;;;;59958:325;;;;60310:12;60295;:27;;;;60333:60;60362:1;60366:2;60370:12;60384:8;60333:20;:60::i;:::-;59001:1400;;;;;;:::o;31369:326::-;31429:4;31686:1;31664:7;:12;;;;;;;;;;;;;;;;;;;;;;;;;:19;:23;31657:30;;31369:326;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:342:1:-;;109:64;124:48;165:6;124:48;:::i;:::-;109:64;:::i;:::-;100:73;;196:6;189:5;182:21;234:4;227:5;223:16;272:3;263:6;258:3;254:16;251:25;248:2;;;289:1;286;279:12;248:2;302:41;336:6;331:3;326;302:41;:::i;:::-;90:259;;;;;;:::o;355:344::-;;458:65;473:49;515:6;473:49;:::i;:::-;458:65;:::i;:::-;449:74;;546:6;539:5;532:21;584:4;577:5;573:16;622:3;613:6;608:3;604:16;601:25;598:2;;;639:1;636;629:12;598:2;652:41;686:6;681:3;676;652:41;:::i;:::-;439:260;;;;;;:::o;705:139::-;;789:6;776:20;767:29;;805:33;832:5;805:33;:::i;:::-;757:87;;;;:::o;850:133::-;;931:6;918:20;909:29;;947:30;971:5;947:30;:::i;:::-;899:84;;;;:::o;989:137::-;;1072:6;1059:20;1050:29;;1088:32;1114:5;1088:32;:::i;:::-;1040:86;;;;:::o;1132:141::-;;1219:6;1213:13;1204:22;;1235:32;1261:5;1235:32;:::i;:::-;1194:79;;;;:::o;1292:271::-;;1396:3;1389:4;1381:6;1377:17;1373:27;1363:2;;1414:1;1411;1404:12;1363:2;1454:6;1441:20;1479:78;1553:3;1545:6;1538:4;1530:6;1526:17;1479:78;:::i;:::-;1470:87;;1353:210;;;;;:::o;1583:273::-;;1688:3;1681:4;1673:6;1669:17;1665:27;1655:2;;1706:1;1703;1696:12;1655:2;1746:6;1733:20;1771:79;1846:3;1838:6;1831:4;1823:6;1819:17;1771:79;:::i;:::-;1762:88;;1645:211;;;;;:::o;1862:139::-;;1946:6;1933:20;1924:29;;1962:33;1989:5;1962:33;:::i;:::-;1914:87;;;;:::o;2007:262::-;;2115:2;2103:9;2094:7;2090:23;2086:32;2083:2;;;2131:1;2128;2121:12;2083:2;2174:1;2199:53;2244:7;2235:6;2224:9;2220:22;2199:53;:::i;:::-;2189:63;;2145:117;2073:196;;;;:::o;2275:407::-;;;2400:2;2388:9;2379:7;2375:23;2371:32;2368:2;;;2416:1;2413;2406:12;2368:2;2459:1;2484:53;2529:7;2520:6;2509:9;2505:22;2484:53;:::i;:::-;2474:63;;2430:117;2586:2;2612:53;2657:7;2648:6;2637:9;2633:22;2612:53;:::i;:::-;2602:63;;2557:118;2358:324;;;;;:::o;2688:552::-;;;;2830:2;2818:9;2809:7;2805:23;2801:32;2798:2;;;2846:1;2843;2836:12;2798:2;2889:1;2914:53;2959:7;2950:6;2939:9;2935:22;2914:53;:::i;:::-;2904:63;;2860:117;3016:2;3042:53;3087:7;3078:6;3067:9;3063:22;3042:53;:::i;:::-;3032:63;;2987:118;3144:2;3170:53;3215:7;3206:6;3195:9;3191:22;3170:53;:::i;:::-;3160:63;;3115:118;2788:452;;;;;:::o;3246:809::-;;;;;3414:3;3402:9;3393:7;3389:23;3385:33;3382:2;;;3431:1;3428;3421:12;3382:2;3474:1;3499:53;3544:7;3535:6;3524:9;3520:22;3499:53;:::i;:::-;3489:63;;3445:117;3601:2;3627:53;3672:7;3663:6;3652:9;3648:22;3627:53;:::i;:::-;3617:63;;3572:118;3729:2;3755:53;3800:7;3791:6;3780:9;3776:22;3755:53;:::i;:::-;3745:63;;3700:118;3885:2;3874:9;3870:18;3857:32;3916:18;3908:6;3905:30;3902:2;;;3948:1;3945;3938:12;3902:2;3976:62;4030:7;4021:6;4010:9;4006:22;3976:62;:::i;:::-;3966:72;;3828:220;3372:683;;;;;;;:::o;4061:401::-;;;4183:2;4171:9;4162:7;4158:23;4154:32;4151:2;;;4199:1;4196;4189:12;4151:2;4242:1;4267:53;4312:7;4303:6;4292:9;4288:22;4267:53;:::i;:::-;4257:63;;4213:117;4369:2;4395:50;4437:7;4428:6;4417:9;4413:22;4395:50;:::i;:::-;4385:60;;4340:115;4141:321;;;;;:::o;4468:407::-;;;4593:2;4581:9;4572:7;4568:23;4564:32;4561:2;;;4609:1;4606;4599:12;4561:2;4652:1;4677:53;4722:7;4713:6;4702:9;4698:22;4677:53;:::i;:::-;4667:63;;4623:117;4779:2;4805:53;4850:7;4841:6;4830:9;4826:22;4805:53;:::i;:::-;4795:63;;4750:118;4551:324;;;;;:::o;4881:260::-;;4988:2;4976:9;4967:7;4963:23;4959:32;4956:2;;;5004:1;5001;4994:12;4956:2;5047:1;5072:52;5116:7;5107:6;5096:9;5092:22;5072:52;:::i;:::-;5062:62;;5018:116;4946:195;;;;:::o;5147:282::-;;5265:2;5253:9;5244:7;5240:23;5236:32;5233:2;;;5281:1;5278;5271:12;5233:2;5324:1;5349:63;5404:7;5395:6;5384:9;5380:22;5349:63;:::i;:::-;5339:73;;5295:127;5223:206;;;;:::o;5435:375::-;;5553:2;5541:9;5532:7;5528:23;5524:32;5521:2;;;5569:1;5566;5559:12;5521:2;5640:1;5629:9;5625:17;5612:31;5670:18;5662:6;5659:30;5656:2;;;5702:1;5699;5692:12;5656:2;5730:63;5785:7;5776:6;5765:9;5761:22;5730:63;:::i;:::-;5720:73;;5583:220;5511:299;;;;:::o;5816:262::-;;5924:2;5912:9;5903:7;5899:23;5895:32;5892:2;;;5940:1;5937;5930:12;5892:2;5983:1;6008:53;6053:7;6044:6;6033:9;6029:22;6008:53;:::i;:::-;5998:63;;5954:117;5882:196;;;;:::o;6084:179::-;;6174:46;6216:3;6208:6;6174:46;:::i;:::-;6252:4;6247:3;6243:14;6229:28;;6164:99;;;;:::o;6269:118::-;6356:24;6374:5;6356:24;:::i;:::-;6351:3;6344:37;6334:53;;:::o;6423:732::-;;6571:54;6619:5;6571:54;:::i;:::-;6641:86;6720:6;6715:3;6641:86;:::i;:::-;6634:93;;6751:56;6801:5;6751:56;:::i;:::-;6830:7;6861:1;6846:284;6871:6;6868:1;6865:13;6846:284;;;6947:6;6941:13;6974:63;7033:3;7018:13;6974:63;:::i;:::-;6967:70;;7060:60;7113:6;7060:60;:::i;:::-;7050:70;;6906:224;6893:1;6890;6886:9;6881:14;;6846:284;;;6850:14;7146:3;7139:10;;6547:608;;;;;;;:::o;7161:109::-;7242:21;7257:5;7242:21;:::i;:::-;7237:3;7230:34;7220:50;;:::o;7276:360::-;;7390:38;7422:5;7390:38;:::i;:::-;7444:70;7507:6;7502:3;7444:70;:::i;:::-;7437:77;;7523:52;7568:6;7563:3;7556:4;7549:5;7545:16;7523:52;:::i;:::-;7600:29;7622:6;7600:29;:::i;:::-;7595:3;7591:39;7584:46;;7366:270;;;;;:::o;7642:364::-;;7758:39;7791:5;7758:39;:::i;:::-;7813:71;7877:6;7872:3;7813:71;:::i;:::-;7806:78;;7893:52;7938:6;7933:3;7926:4;7919:5;7915:16;7893:52;:::i;:::-;7970:29;7992:6;7970:29;:::i;:::-;7965:3;7961:39;7954:46;;7734:272;;;;;:::o;8012:377::-;;8146:39;8179:5;8146:39;:::i;:::-;8201:89;8283:6;8278:3;8201:89;:::i;:::-;8194:96;;8299:52;8344:6;8339:3;8332:4;8325:5;8321:16;8299:52;:::i;:::-;8376:6;8371:3;8367:16;8360:23;;8122:267;;;;;:::o;8395:366::-;;8558:67;8622:2;8617:3;8558:67;:::i;:::-;8551:74;;8655:34;8651:1;8646:3;8642:11;8635:55;8721:4;8716:2;8711:3;8707:12;8700:26;8752:2;8747:3;8743:12;8736:19;;8541:220;;;:::o;8767:370::-;;8930:67;8994:2;8989:3;8930:67;:::i;:::-;8923:74;;9027:34;9023:1;9018:3;9014:11;9007:55;9093:8;9088:2;9083:3;9079:12;9072:30;9128:2;9123:3;9119:12;9112:19;;8913:224;;;:::o;9143:374::-;;9306:67;9370:2;9365:3;9306:67;:::i;:::-;9299:74;;9403:34;9399:1;9394:3;9390:11;9383:55;9469:12;9464:2;9459:3;9455:12;9448:34;9508:2;9503:3;9499:12;9492:19;;9289:228;;;:::o;9523:367::-;;9686:67;9750:2;9745:3;9686:67;:::i;:::-;9679:74;;9783:34;9779:1;9774:3;9770:11;9763:55;9849:5;9844:2;9839:3;9835:12;9828:27;9881:2;9876:3;9872:12;9865:19;;9669:221;;;:::o;9896:369::-;;10059:67;10123:2;10118:3;10059:67;:::i;:::-;10052:74;;10156:34;10152:1;10147:3;10143:11;10136:55;10222:7;10217:2;10212:3;10208:12;10201:29;10256:2;10251:3;10247:12;10240:19;;10042:223;;;:::o;10271:324::-;;10434:67;10498:2;10493:3;10434:67;:::i;:::-;10427:74;;10531:28;10527:1;10522:3;10518:11;10511:49;10586:2;10581:3;10577:12;10570:19;;10417:178;;;:::o;10601:389::-;;10764:67;10828:2;10823:3;10764:67;:::i;:::-;10757:74;;10861:34;10857:1;10852:3;10848:11;10841:55;10927:27;10922:2;10917:3;10913:12;10906:49;10981:2;10976:3;10972:12;10965:19;;10747:243;;;:::o;10996:375::-;;11159:67;11223:2;11218:3;11159:67;:::i;:::-;11152:74;;11256:34;11252:1;11247:3;11243:11;11236:55;11322:13;11317:2;11312:3;11308:12;11301:35;11362:2;11357:3;11353:12;11346:19;;11142:229;;;:::o;11377:323::-;;11540:67;11604:2;11599:3;11540:67;:::i;:::-;11533:74;;11637:27;11633:1;11628:3;11624:11;11617:48;11691:2;11686:3;11682:12;11675:19;;11523:177;;;:::o;11706:370::-;;11869:67;11933:2;11928:3;11869:67;:::i;:::-;11862:74;;11966:34;11962:1;11957:3;11953:11;11946:55;12032:8;12027:2;12022:3;12018:12;12011:30;12067:2;12062:3;12058:12;12051:19;;11852:224;;;:::o;12082:330::-;;12245:67;12309:2;12304:3;12245:67;:::i;:::-;12238:74;;12342:34;12338:1;12333:3;12329:11;12322:55;12403:2;12398:3;12394:12;12387:19;;12228:184;;;:::o;12418:379::-;;12581:67;12645:2;12640:3;12581:67;:::i;:::-;12574:74;;12678:34;12674:1;12669:3;12665:11;12658:55;12744:17;12739:2;12734:3;12730:12;12723:39;12788:2;12783:3;12779:12;12772:19;;12564:233;;;:::o;12803:324::-;;12966:67;13030:2;13025:3;12966:67;:::i;:::-;12959:74;;13063:28;13059:1;13054:3;13050:11;13043:49;13118:2;13113:3;13109:12;13102:19;;12949:178;;;:::o;13133:382::-;;13296:67;13360:2;13355:3;13296:67;:::i;:::-;13289:74;;13393:34;13389:1;13384:3;13380:11;13373:55;13459:20;13454:2;13449:3;13445:12;13438:42;13506:2;13501:3;13497:12;13490:19;;13279:236;;;:::o;13521:318::-;;13684:67;13748:2;13743:3;13684:67;:::i;:::-;13677:74;;13781:22;13777:1;13772:3;13768:11;13761:43;13830:2;13825:3;13821:12;13814:19;;13667:172;;;:::o;13845:366::-;;14008:67;14072:2;14067:3;14008:67;:::i;:::-;14001:74;;14105:34;14101:1;14096:3;14092:11;14085:55;14171:4;14166:2;14161:3;14157:12;14150:26;14202:2;14197:3;14193:12;14186:19;;13991:220;;;:::o;14217:368::-;;14380:67;14444:2;14439:3;14380:67;:::i;:::-;14373:74;;14477:34;14473:1;14468:3;14464:11;14457:55;14543:6;14538:2;14533:3;14529:12;14522:28;14576:2;14571:3;14567:12;14560:19;;14363:222;;;:::o;14591:297::-;;14771:83;14852:1;14847:3;14771:83;:::i;:::-;14764:90;;14880:1;14875:3;14871:11;14864:18;;14754:134;;;:::o;14894:314::-;;15057:67;15121:2;15116:3;15057:67;:::i;:::-;15050:74;;15154:18;15150:1;15145:3;15141:11;15134:39;15199:2;15194:3;15190:12;15183:19;;15040:168;;;:::o;15214:383::-;;15377:67;15441:2;15436:3;15377:67;:::i;:::-;15370:74;;15474:34;15470:1;15465:3;15461:11;15454:55;15540:21;15535:2;15530:3;15526:12;15519:43;15588:2;15583:3;15579:12;15572:19;;15360:237;;;:::o;15603:327::-;;15766:67;15830:2;15825:3;15766:67;:::i;:::-;15759:74;;15863:31;15859:1;15854:3;15850:11;15843:52;15921:2;15916:3;15912:12;15905:19;;15749:181;;;:::o;15936:365::-;;16099:67;16163:2;16158:3;16099:67;:::i;:::-;16092:74;;16196:34;16192:1;16187:3;16183:11;16176:55;16262:3;16257:2;16252:3;16248:12;16241:25;16292:2;16287:3;16283:12;16276:19;;16082:219;;;:::o;16307:365::-;;16470:67;16534:2;16529:3;16470:67;:::i;:::-;16463:74;;16567:34;16563:1;16558:3;16554:11;16547:55;16633:3;16628:2;16623:3;16619:12;16612:25;16663:2;16658:3;16654:12;16647:19;;16453:219;;;:::o;16678:378::-;;16841:67;16905:2;16900:3;16841:67;:::i;:::-;16834:74;;16938:34;16934:1;16929:3;16925:11;16918:55;17004:16;16999:2;16994:3;16990:12;16983:38;17047:2;17042:3;17038:12;17031:19;;16824:232;;;:::o;17062:379::-;;17225:67;17289:2;17284:3;17225:67;:::i;:::-;17218:74;;17322:34;17318:1;17313:3;17309:11;17302:55;17388:17;17383:2;17378:3;17374:12;17367:39;17432:2;17427:3;17423:12;17416:19;;17208:233;;;:::o;17447:377::-;;17610:67;17674:2;17669:3;17610:67;:::i;:::-;17603:74;;17707:34;17703:1;17698:3;17694:11;17687:55;17773:15;17768:2;17763:3;17759:12;17752:37;17815:2;17810:3;17806:12;17799:19;;17593:231;;;:::o;17830:366::-;;17993:67;18057:2;18052:3;17993:67;:::i;:::-;17986:74;;18090:34;18086:1;18081:3;18077:11;18070:55;18156:4;18151:2;18146:3;18142:12;18135:26;18187:2;18182:3;18178:12;18171:19;;17976:220;;;:::o;18202:108::-;18279:24;18297:5;18279:24;:::i;:::-;18274:3;18267:37;18257:53;;:::o;18316:118::-;18403:24;18421:5;18403:24;:::i;:::-;18398:3;18391:37;18381:53;;:::o;18440:435::-;;18642:95;18733:3;18724:6;18642:95;:::i;:::-;18635:102;;18754:95;18845:3;18836:6;18754:95;:::i;:::-;18747:102;;18866:3;18859:10;;18624:251;;;;;:::o;18881:379::-;;19087:147;19230:3;19087:147;:::i;:::-;19080:154;;19251:3;19244:10;;19069:191;;;:::o;19266:222::-;;19397:2;19386:9;19382:18;19374:26;;19410:71;19478:1;19467:9;19463:17;19454:6;19410:71;:::i;:::-;19364:124;;;;:::o;19494:640::-;;19727:3;19716:9;19712:19;19704:27;;19741:71;19809:1;19798:9;19794:17;19785:6;19741:71;:::i;:::-;19822:72;19890:2;19879:9;19875:18;19866:6;19822:72;:::i;:::-;19904;19972:2;19961:9;19957:18;19948:6;19904:72;:::i;:::-;20023:9;20017:4;20013:20;20008:2;19997:9;19993:18;19986:48;20051:76;20122:4;20113:6;20051:76;:::i;:::-;20043:84;;19694:440;;;;;;;:::o;20140:373::-;;20321:2;20310:9;20306:18;20298:26;;20370:9;20364:4;20360:20;20356:1;20345:9;20341:17;20334:47;20398:108;20501:4;20492:6;20398:108;:::i;:::-;20390:116;;20288:225;;;;:::o;20519:210::-;;20644:2;20633:9;20629:18;20621:26;;20657:65;20719:1;20708:9;20704:17;20695:6;20657:65;:::i;:::-;20611:118;;;;:::o;20735:313::-;;20886:2;20875:9;20871:18;20863:26;;20935:9;20929:4;20925:20;20921:1;20910:9;20906:17;20899:47;20963:78;21036:4;21027:6;20963:78;:::i;:::-;20955:86;;20853:195;;;;:::o;21054:419::-;;21258:2;21247:9;21243:18;21235:26;;21307:9;21301:4;21297:20;21293:1;21282:9;21278:17;21271:47;21335:131;21461:4;21335:131;:::i;:::-;21327:139;;21225:248;;;:::o;21479:419::-;;21683:2;21672:9;21668:18;21660:26;;21732:9;21726:4;21722:20;21718:1;21707:9;21703:17;21696:47;21760:131;21886:4;21760:131;:::i;:::-;21752:139;;21650:248;;;:::o;21904:419::-;;22108:2;22097:9;22093:18;22085:26;;22157:9;22151:4;22147:20;22143:1;22132:9;22128:17;22121:47;22185:131;22311:4;22185:131;:::i;:::-;22177:139;;22075:248;;;:::o;22329:419::-;;22533:2;22522:9;22518:18;22510:26;;22582:9;22576:4;22572:20;22568:1;22557:9;22553:17;22546:47;22610:131;22736:4;22610:131;:::i;:::-;22602:139;;22500:248;;;:::o;22754:419::-;;22958:2;22947:9;22943:18;22935:26;;23007:9;23001:4;22997:20;22993:1;22982:9;22978:17;22971:47;23035:131;23161:4;23035:131;:::i;:::-;23027:139;;22925:248;;;:::o;23179:419::-;;23383:2;23372:9;23368:18;23360:26;;23432:9;23426:4;23422:20;23418:1;23407:9;23403:17;23396:47;23460:131;23586:4;23460:131;:::i;:::-;23452:139;;23350:248;;;:::o;23604:419::-;;23808:2;23797:9;23793:18;23785:26;;23857:9;23851:4;23847:20;23843:1;23832:9;23828:17;23821:47;23885:131;24011:4;23885:131;:::i;:::-;23877:139;;23775:248;;;:::o;24029:419::-;;24233:2;24222:9;24218:18;24210:26;;24282:9;24276:4;24272:20;24268:1;24257:9;24253:17;24246:47;24310:131;24436:4;24310:131;:::i;:::-;24302:139;;24200:248;;;:::o;24454:419::-;;24658:2;24647:9;24643:18;24635:26;;24707:9;24701:4;24697:20;24693:1;24682:9;24678:17;24671:47;24735:131;24861:4;24735:131;:::i;:::-;24727:139;;24625:248;;;:::o;24879:419::-;;25083:2;25072:9;25068:18;25060:26;;25132:9;25126:4;25122:20;25118:1;25107:9;25103:17;25096:47;25160:131;25286:4;25160:131;:::i;:::-;25152:139;;25050:248;;;:::o;25304:419::-;;25508:2;25497:9;25493:18;25485:26;;25557:9;25551:4;25547:20;25543:1;25532:9;25528:17;25521:47;25585:131;25711:4;25585:131;:::i;:::-;25577:139;;25475:248;;;:::o;25729:419::-;;25933:2;25922:9;25918:18;25910:26;;25982:9;25976:4;25972:20;25968:1;25957:9;25953:17;25946:47;26010:131;26136:4;26010:131;:::i;:::-;26002:139;;25900:248;;;:::o;26154:419::-;;26358:2;26347:9;26343:18;26335:26;;26407:9;26401:4;26397:20;26393:1;26382:9;26378:17;26371:47;26435:131;26561:4;26435:131;:::i;:::-;26427:139;;26325:248;;;:::o;26579:419::-;;26783:2;26772:9;26768:18;26760:26;;26832:9;26826:4;26822:20;26818:1;26807:9;26803:17;26796:47;26860:131;26986:4;26860:131;:::i;:::-;26852:139;;26750:248;;;:::o;27004:419::-;;27208:2;27197:9;27193:18;27185:26;;27257:9;27251:4;27247:20;27243:1;27232:9;27228:17;27221:47;27285:131;27411:4;27285:131;:::i;:::-;27277:139;;27175:248;;;:::o;27429:419::-;;27633:2;27622:9;27618:18;27610:26;;27682:9;27676:4;27672:20;27668:1;27657:9;27653:17;27646:47;27710:131;27836:4;27710:131;:::i;:::-;27702:139;;27600:248;;;:::o;27854:419::-;;28058:2;28047:9;28043:18;28035:26;;28107:9;28101:4;28097:20;28093:1;28082:9;28078:17;28071:47;28135:131;28261:4;28135:131;:::i;:::-;28127:139;;28025:248;;;:::o;28279:419::-;;28483:2;28472:9;28468:18;28460:26;;28532:9;28526:4;28522:20;28518:1;28507:9;28503:17;28496:47;28560:131;28686:4;28560:131;:::i;:::-;28552:139;;28450:248;;;:::o;28704:419::-;;28908:2;28897:9;28893:18;28885:26;;28957:9;28951:4;28947:20;28943:1;28932:9;28928:17;28921:47;28985:131;29111:4;28985:131;:::i;:::-;28977:139;;28875:248;;;:::o;29129:419::-;;29333:2;29322:9;29318:18;29310:26;;29382:9;29376:4;29372:20;29368:1;29357:9;29353:17;29346:47;29410:131;29536:4;29410:131;:::i;:::-;29402:139;;29300:248;;;:::o;29554:419::-;;29758:2;29747:9;29743:18;29735:26;;29807:9;29801:4;29797:20;29793:1;29782:9;29778:17;29771:47;29835:131;29961:4;29835:131;:::i;:::-;29827:139;;29725:248;;;:::o;29979:419::-;;30183:2;30172:9;30168:18;30160:26;;30232:9;30226:4;30222:20;30218:1;30207:9;30203:17;30196:47;30260:131;30386:4;30260:131;:::i;:::-;30252:139;;30150:248;;;:::o;30404:419::-;;30608:2;30597:9;30593:18;30585:26;;30657:9;30651:4;30647:20;30643:1;30632:9;30628:17;30621:47;30685:131;30811:4;30685:131;:::i;:::-;30677:139;;30575:248;;;:::o;30829:419::-;;31033:2;31022:9;31018:18;31010:26;;31082:9;31076:4;31072:20;31068:1;31057:9;31053:17;31046:47;31110:131;31236:4;31110:131;:::i;:::-;31102:139;;31000:248;;;:::o;31254:419::-;;31458:2;31447:9;31443:18;31435:26;;31507:9;31501:4;31497:20;31493:1;31482:9;31478:17;31471:47;31535:131;31661:4;31535:131;:::i;:::-;31527:139;;31425:248;;;:::o;31679:419::-;;31883:2;31872:9;31868:18;31860:26;;31932:9;31926:4;31922:20;31918:1;31907:9;31903:17;31896:47;31960:131;32086:4;31960:131;:::i;:::-;31952:139;;31850:248;;;:::o;32104:222::-;;32235:2;32224:9;32220:18;32212:26;;32248:71;32316:1;32305:9;32301:17;32292:6;32248:71;:::i;:::-;32202:124;;;;:::o;32332:283::-;;32398:2;32392:9;32382:19;;32440:4;32432:6;32428:17;32547:6;32535:10;32532:22;32511:18;32499:10;32496:34;32493:62;32490:2;;;32558:18;;:::i;:::-;32490:2;32598:10;32594:2;32587:22;32372:243;;;;:::o;32621:331::-;;32772:18;32764:6;32761:30;32758:2;;;32794:18;;:::i;:::-;32758:2;32879:4;32875:9;32868:4;32860:6;32856:17;32852:33;32844:41;;32940:4;32934;32930:15;32922:23;;32687:265;;;:::o;32958:332::-;;33110:18;33102:6;33099:30;33096:2;;;33132:18;;:::i;:::-;33096:2;33217:4;33213:9;33206:4;33198:6;33194:17;33190:33;33182:41;;33278:4;33272;33268:15;33260:23;;33025:265;;;:::o;33296:132::-;;33386:3;33378:11;;33416:4;33411:3;33407:14;33399:22;;33368:60;;;:::o;33434:114::-;;33535:5;33529:12;33519:22;;33508:40;;;:::o;33554:98::-;;33639:5;33633:12;33623:22;;33612:40;;;:::o;33658:99::-;;33744:5;33738:12;33728:22;;33717:40;;;:::o;33763:113::-;;33865:4;33860:3;33856:14;33848:22;;33838:38;;;:::o;33882:184::-;;34015:6;34010:3;34003:19;34055:4;34050:3;34046:14;34031:29;;33993:73;;;;:::o;34072:168::-;;34189:6;34184:3;34177:19;34229:4;34224:3;34220:14;34205:29;;34167:73;;;;:::o;34246:147::-;;34384:3;34369:18;;34359:34;;;;:::o;34399:169::-;;34517:6;34512:3;34505:19;34557:4;34552:3;34548:14;34533:29;;34495:73;;;;:::o;34574:148::-;;34713:3;34698:18;;34688:34;;;;:::o;34728:273::-;;34787:20;34805:1;34787:20;:::i;:::-;34782:25;;34821:20;34839:1;34821:20;:::i;:::-;34816:25;;34943:1;34907:34;34903:42;34900:1;34897:49;34894:2;;;34949:18;;:::i;:::-;34894:2;34993:1;34990;34986:9;34979:16;;34772:229;;;;:::o;35007:305::-;;35066:20;35084:1;35066:20;:::i;:::-;35061:25;;35100:20;35118:1;35100:20;:::i;:::-;35095:25;;35254:1;35186:66;35182:74;35179:1;35176:81;35173:2;;;35260:18;;:::i;:::-;35173:2;35304:1;35301;35297:9;35290:16;;35051:261;;;;:::o;35318:185::-;;35375:20;35393:1;35375:20;:::i;:::-;35370:25;;35409:20;35427:1;35409:20;:::i;:::-;35404:25;;35448:1;35438:2;;35453:18;;:::i;:::-;35438:2;35495:1;35492;35488:9;35483:14;;35360:143;;;;:::o;35509:348::-;;35572:20;35590:1;35572:20;:::i;:::-;35567:25;;35606:20;35624:1;35606:20;:::i;:::-;35601:25;;35794:1;35726:66;35722:74;35719:1;35716:81;35711:1;35704:9;35697:17;35693:105;35690:2;;;35801:18;;:::i;:::-;35690:2;35849:1;35846;35842:9;35831:20;;35557:300;;;;:::o;35863:191::-;;35923:20;35941:1;35923:20;:::i;:::-;35918:25;;35957:20;35975:1;35957:20;:::i;:::-;35952:25;;35996:1;35993;35990:8;35987:2;;;36001:18;;:::i;:::-;35987:2;36046:1;36043;36039:9;36031:17;;35908:146;;;;:::o;36060:191::-;;36120:20;36138:1;36120:20;:::i;:::-;36115:25;;36154:20;36172:1;36154:20;:::i;:::-;36149:25;;36193:1;36190;36187:8;36184:2;;;36198:18;;:::i;:::-;36184:2;36243:1;36240;36236:9;36228:17;;36105:146;;;;:::o;36257:96::-;;36323:24;36341:5;36323:24;:::i;:::-;36312:35;;36302:51;;;:::o;36359:90::-;;36436:5;36429:13;36422:21;36411:32;;36401:48;;;:::o;36455:149::-;;36531:66;36524:5;36520:78;36509:89;;36499:105;;;:::o;36610:118::-;;36687:34;36680:5;36676:46;36665:57;;36655:73;;;:::o;36734:126::-;;36811:42;36804:5;36800:54;36789:65;;36779:81;;;:::o;36866:77::-;;36932:5;36921:16;;36911:32;;;:::o;36949:154::-;37033:6;37028:3;37023;37010:30;37095:1;37086:6;37081:3;37077:16;37070:27;37000:103;;;:::o;37109:307::-;37177:1;37187:113;37201:6;37198:1;37195:13;37187:113;;;37286:1;37281:3;37277:11;37271:18;37267:1;37262:3;37258:11;37251:39;37223:2;37220:1;37216:10;37211:15;;37187:113;;;37318:6;37315:1;37312:13;37309:2;;;37398:1;37389:6;37384:3;37380:16;37373:27;37309:2;37158:258;;;;:::o;37422:171::-;;37484:24;37502:5;37484:24;:::i;:::-;37475:33;;37530:4;37523:5;37520:15;37517:2;;;37538:18;;:::i;:::-;37517:2;37585:1;37578:5;37574:13;37567:20;;37465:128;;;:::o;37599:320::-;;37680:1;37674:4;37670:12;37660:22;;37727:1;37721:4;37717:12;37748:18;37738:2;;37804:4;37796:6;37792:17;37782:27;;37738:2;37866;37858:6;37855:14;37835:18;37832:38;37829:2;;;37885:18;;:::i;:::-;37829:2;37650:269;;;;:::o;37925:233::-;;37987:24;38005:5;37987:24;:::i;:::-;37978:33;;38033:66;38026:5;38023:77;38020:2;;;38103:18;;:::i;:::-;38020:2;38150:1;38143:5;38139:13;38132:20;;37968:190;;;:::o;38164:176::-;;38213:20;38231:1;38213:20;:::i;:::-;38208:25;;38247:20;38265:1;38247:20;:::i;:::-;38242:25;;38286:1;38276:2;;38291:18;;:::i;:::-;38276:2;38332:1;38329;38325:9;38320:14;;38198:142;;;;:::o;38346:180::-;38394:77;38391:1;38384:88;38491:4;38488:1;38481:15;38515:4;38512:1;38505:15;38532:180;38580:77;38577:1;38570:88;38677:4;38674:1;38667:15;38701:4;38698:1;38691:15;38718:180;38766:77;38763:1;38756:88;38863:4;38860:1;38853:15;38887:4;38884:1;38877:15;38904:180;38952:77;38949:1;38942:88;39049:4;39046:1;39039:15;39073:4;39070:1;39063:15;39090:102;;39182:2;39178:7;39173:2;39166:5;39162:14;39158:28;39148:38;;39138:54;;;:::o;39198:122::-;39271:24;39289:5;39271:24;:::i;:::-;39264:5;39261:35;39251:2;;39310:1;39307;39300:12;39251:2;39241:79;:::o;39326:116::-;39396:21;39411:5;39396:21;:::i;:::-;39389:5;39386:32;39376:2;;39432:1;39429;39422:12;39376:2;39366:76;:::o;39448:120::-;39520:23;39537:5;39520:23;:::i;:::-;39513:5;39510:34;39500:2;;39558:1;39555;39548:12;39500:2;39490:78;:::o;39574:122::-;39647:24;39665:5;39647:24;:::i;:::-;39640:5;39637:35;39627:2;;39686:1;39683;39676:12;39627:2;39617:79;:::o

Swarm Source

ipfs://c1f93d5e25123960a62153efa9bbcc20877a3b5017d2c78d93d4475320cb7d73

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