MATIC Price: $0.605398 (-6.07%)
Gas: 30 GWei
 

Overview

Max Total Supply

7,579 THENOISE

Holders

7,130

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Balance
1 THENOISE
0x99377f42b13bd64d18b64c6cce0807f00488547a
Loading...
Loading
Loading...
Loading
Loading...
Loading

Click here to update the token information / general information

Contract Source Code Verified (Exact Match)

Contract Name:
LMBTHENOISE

Compiler Version
v0.8.13+commit.abaa5c0e

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at polygonscan.com on 2023-04-18
*/

// File: operator-filter-registry/src/lib/Constants.sol


pragma solidity ^0.8.13;

address constant CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS = 0x000000000000AAeB6D7670E522A718067333cd4E;
address constant CANONICAL_CORI_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6;

// File: operator-filter-registry/src/IOperatorFilterRegistry.sol


pragma solidity ^0.8.13;

interface IOperatorFilterRegistry {
    /**
     * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns
     *         true if supplied registrant address is not registered.
     */
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);

    /**
     * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner.
     */
    function register(address registrant) external;

    /**
     * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes.
     */
    function registerAndSubscribe(address registrant, address subscription) external;

    /**
     * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another
     *         address without subscribing.
     */
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;

    /**
     * @notice Unregisters an address with the registry and removes its subscription. May be called by address itself or by EIP-173 owner.
     *         Note that this does not remove any filtered addresses or codeHashes.
     *         Also note that any subscriptions to this registrant will still be active and follow the existing filtered addresses and codehashes.
     */
    function unregister(address addr) external;

    /**
     * @notice Update an operator address for a registered address - when filtered is true, the operator is filtered.
     */
    function updateOperator(address registrant, address operator, bool filtered) external;

    /**
     * @notice Update multiple operators for a registered address - when filtered is true, the operators will be filtered. Reverts on duplicates.
     */
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;

    /**
     * @notice Update a codeHash for a registered address - when filtered is true, the codeHash is filtered.
     */
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;

    /**
     * @notice Update multiple codeHashes for a registered address - when filtered is true, the codeHashes will be filtered. Reverts on duplicates.
     */
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;

    /**
     * @notice Subscribe an address to another registrant's filtered operators and codeHashes. Will remove previous
     *         subscription if present.
     *         Note that accounts with subscriptions may go on to subscribe to other accounts - in this case,
     *         subscriptions will not be forwarded. Instead the former subscription's existing entries will still be
     *         used.
     */
    function subscribe(address registrant, address registrantToSubscribe) external;

    /**
     * @notice Unsubscribe an address from its current subscribed registrant, and optionally copy its filtered operators and codeHashes.
     */
    function unsubscribe(address registrant, bool copyExistingEntries) external;

    /**
     * @notice Get the subscription address of a given registrant, if any.
     */
    function subscriptionOf(address addr) external returns (address registrant);

    /**
     * @notice Get the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscribers(address registrant) external returns (address[] memory);

    /**
     * @notice Get the subscriber at a given index in the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscriberAt(address registrant, uint256 index) external returns (address);

    /**
     * @notice Copy filtered operators and codeHashes from a different registrantToCopy to addr.
     */
    function copyEntriesOf(address registrant, address registrantToCopy) external;

    /**
     * @notice Returns true if operator is filtered by a given address or its subscription.
     */
    function isOperatorFiltered(address registrant, address operator) external returns (bool);

    /**
     * @notice Returns true if the hash of an address's code is filtered by a given address or its subscription.
     */
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);

    /**
     * @notice Returns true if a codeHash is filtered by a given address or its subscription.
     */
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);

    /**
     * @notice Returns a list of filtered operators for a given address or its subscription.
     */
    function filteredOperators(address addr) external returns (address[] memory);

    /**
     * @notice Returns the set of filtered codeHashes for a given address or its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);

    /**
     * @notice Returns the filtered operator at the given index of the set of filtered operators for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);

    /**
     * @notice Returns the filtered codeHash at the given index of the list of filtered codeHashes for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);

    /**
     * @notice Returns true if an address has registered
     */
    function isRegistered(address addr) external returns (bool);

    /**
     * @dev Convenience method to compute the code hash of an arbitrary contract
     */
    function codeHashOf(address addr) external returns (bytes32);
}

// File: operator-filter-registry/src/OperatorFilterer.sol


pragma solidity ^0.8.13;


/**
 * @title  OperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 *         Please note that if your token contract does not provide an owner with EIP-173, it must provide
 *         administration methods on the contract itself to interact with the registry otherwise the subscription
 *         will be locked to the options set during construction.
 */

abstract contract OperatorFilterer {
    /// @dev Emitted when an operator is not allowed.
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
        IOperatorFilterRegistry(CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS);

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

    /**
     * @dev A helper function to check if an operator is allowed.
     */
    modifier onlyAllowedOperator(address from) virtual {
        // Allow spending tokens from addresses with balance
        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
        // from an EOA.
        if (from != msg.sender) {
            _checkFilterOperator(msg.sender);
        }
        _;
    }

    /**
     * @dev A helper function to check if an operator approval is allowed.
     */
    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    /**
     * @dev A helper function to check if an operator is allowed.
     */
    function _checkFilterOperator(address operator) internal view virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            // under normal circumstances, this function will revert rather than return false, but inheriting contracts
            // may specify their own OperatorFilterRegistry implementations, which may behave differently
            if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}

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


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

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


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

pragma solidity ^0.8.0;


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

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

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

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

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


// OpenZeppelin Contracts (last updated v4.8.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 // Deprecated in v4.8
    }

    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");
        }
    }

    /**
     * @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) {
        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.
            /// @solidity memory-safe-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 {
            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 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: erc721a/contracts/IERC721A.sol


// ERC721A Contracts v4.2.3
// Creator: Chiru Labs

pragma solidity ^0.8.4;

/**
 * @dev Interface of ERC721A.
 */
interface IERC721A {
    /**
     * The caller must own the token or be an approved operator.
     */
    error ApprovalCallerNotOwnerNorApproved();

    /**
     * The token does not exist.
     */
    error ApprovalQueryForNonexistentToken();

    /**
     * Cannot query the balance for the zero address.
     */
    error BalanceQueryForZeroAddress();

    /**
     * Cannot mint to the zero address.
     */
    error MintToZeroAddress();

    /**
     * The quantity of tokens minted must be more than zero.
     */
    error MintZeroQuantity();

    /**
     * The token does not exist.
     */
    error OwnerQueryForNonexistentToken();

    /**
     * The caller must own the token or be an approved operator.
     */
    error TransferCallerNotOwnerNorApproved();

    /**
     * The token must be owned by `from`.
     */
    error TransferFromIncorrectOwner();

    /**
     * Cannot safely transfer to a contract that does not implement the
     * ERC721Receiver interface.
     */
    error TransferToNonERC721ReceiverImplementer();

    /**
     * Cannot transfer to the zero address.
     */
    error TransferToZeroAddress();

    /**
     * The token does not exist.
     */
    error URIQueryForNonexistentToken();

    /**
     * The `quantity` minted with ERC2309 exceeds the safety limit.
     */
    error MintERC2309QuantityExceedsLimit();

    /**
     * The `extraData` cannot be set on an unintialized ownership slot.
     */
    error OwnershipNotInitializedForExtraData();

    // =============================================================
    //                            STRUCTS
    // =============================================================

    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Stores the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
        // Arbitrary data similar to `startTimestamp` that can be set via {_extraData}.
        uint24 extraData;
    }

    // =============================================================
    //                         TOKEN COUNTERS
    // =============================================================

    /**
     * @dev Returns the total number of tokens in existence.
     * Burned tokens will reduce the count.
     * To get the total number of tokens minted, please see {_totalMinted}.
     */
    function totalSupply() external view returns (uint256);

    // =============================================================
    //                            IERC165
    // =============================================================

    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);

    // =============================================================
    //                            IERC721
    // =============================================================

    /**
     * @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,
        bytes calldata data
    ) external payable;

    /**
     * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external payable;

    /**
     * @dev Transfers `tokenId` 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 payable;

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

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

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

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

    // =============================================================
    //                        IERC721Metadata
    // =============================================================

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

    // =============================================================
    //                           IERC2309
    // =============================================================

    /**
     * @dev Emitted when tokens in `fromTokenId` to `toTokenId`
     * (inclusive) is transferred from `from` to `to`, as defined in the
     * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309) standard.
     *
     * See {_mintERC2309} for more details.
     */
    event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);
}

// File: erc721a/contracts/ERC721A.sol


// ERC721A Contracts v4.2.3
// Creator: Chiru Labs

pragma solidity ^0.8.4;


/**
 * @dev Interface of ERC721 token receiver.
 */
interface ERC721A__IERC721Receiver {
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

/**
 * @title ERC721A
 *
 * @dev Implementation of the [ERC721](https://eips.ethereum.org/EIPS/eip-721)
 * Non-Fungible Token Standard, including the Metadata extension.
 * Optimized for lower gas during batch mints.
 *
 * Token IDs are minted in sequential order (e.g. 0, 1, 2, 3, ...)
 * starting from `_startTokenId()`.
 *
 * Assumptions:
 *
 * - An owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 * - The maximum token ID cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is IERC721A {
    // Bypass for a `--via-ir` bug (https://github.com/chiru-labs/ERC721A/pull/364).
    struct TokenApprovalRef {
        address value;
    }

    // =============================================================
    //                           CONSTANTS
    // =============================================================

    // Mask of an entry in packed address data.
    uint256 private constant _BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;

    // The bit position of `numberMinted` in packed address data.
    uint256 private constant _BITPOS_NUMBER_MINTED = 64;

    // The bit position of `numberBurned` in packed address data.
    uint256 private constant _BITPOS_NUMBER_BURNED = 128;

    // The bit position of `aux` in packed address data.
    uint256 private constant _BITPOS_AUX = 192;

    // Mask of all 256 bits in packed address data except the 64 bits for `aux`.
    uint256 private constant _BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;

    // The bit position of `startTimestamp` in packed ownership.
    uint256 private constant _BITPOS_START_TIMESTAMP = 160;

    // The bit mask of the `burned` bit in packed ownership.
    uint256 private constant _BITMASK_BURNED = 1 << 224;

    // The bit position of the `nextInitialized` bit in packed ownership.
    uint256 private constant _BITPOS_NEXT_INITIALIZED = 225;

    // The bit mask of the `nextInitialized` bit in packed ownership.
    uint256 private constant _BITMASK_NEXT_INITIALIZED = 1 << 225;

    // The bit position of `extraData` in packed ownership.
    uint256 private constant _BITPOS_EXTRA_DATA = 232;

    // Mask of all 256 bits in a packed ownership except the 24 bits for `extraData`.
    uint256 private constant _BITMASK_EXTRA_DATA_COMPLEMENT = (1 << 232) - 1;

    // The mask of the lower 160 bits for addresses.
    uint256 private constant _BITMASK_ADDRESS = (1 << 160) - 1;

    // The maximum `quantity` that can be minted with {_mintERC2309}.
    // This limit is to prevent overflows on the address data entries.
    // For a limit of 5000, a total of 3.689e15 calls to {_mintERC2309}
    // is required to cause an overflow, which is unrealistic.
    uint256 private constant _MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000;

    // The `Transfer` event signature is given by:
    // `keccak256(bytes("Transfer(address,address,uint256)"))`.
    bytes32 private constant _TRANSFER_EVENT_SIGNATURE =
        0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;

    // =============================================================
    //                            STORAGE
    // =============================================================

    // The next token ID to be minted.
    uint256 private _currentIndex;

    // The number of tokens burned.
    uint256 private _burnCounter;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned.
    // See {_packedOwnershipOf} implementation for details.
    //
    // Bits Layout:
    // - [0..159]   `addr`
    // - [160..223] `startTimestamp`
    // - [224]      `burned`
    // - [225]      `nextInitialized`
    // - [232..255] `extraData`
    mapping(uint256 => uint256) private _packedOwnerships;

    // Mapping owner address to address data.
    //
    // Bits Layout:
    // - [0..63]    `balance`
    // - [64..127]  `numberMinted`
    // - [128..191] `numberBurned`
    // - [192..255] `aux`
    mapping(address => uint256) private _packedAddressData;

    // Mapping from token ID to approved address.
    mapping(uint256 => TokenApprovalRef) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    // =============================================================
    //                          CONSTRUCTOR
    // =============================================================

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _currentIndex = _startTokenId();
    }

    // =============================================================
    //                   TOKEN COUNTING OPERATIONS
    // =============================================================

    /**
     * @dev Returns the starting token ID.
     * To change the starting token ID, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @dev Returns the next token ID to be minted.
     */
    function _nextTokenId() internal view virtual returns (uint256) {
        return _currentIndex;
    }

    /**
     * @dev Returns the total number of tokens in existence.
     * Burned tokens will reduce the count.
     * To get the total number of tokens minted, please see {_totalMinted}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than `_currentIndex - _startTokenId()` times.
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    /**
     * @dev Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view virtual returns (uint256) {
        // Counter underflow is impossible as `_currentIndex` does not decrement,
        // and it is initialized to `_startTokenId()`.
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

    /**
     * @dev Returns the total number of tokens burned.
     */
    function _totalBurned() internal view virtual returns (uint256) {
        return _burnCounter;
    }

    // =============================================================
    //                    ADDRESS DATA OPERATIONS
    // =============================================================

    /**
     * @dev Returns the number of tokens in `owner`'s account.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return _packedAddressData[owner] & _BITMASK_ADDRESS_DATA_ENTRY;
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return (_packedAddressData[owner] >> _BITPOS_NUMBER_MINTED) & _BITMASK_ADDRESS_DATA_ENTRY;
    }

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

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

    /**
     * Sets the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal virtual {
        uint256 packed = _packedAddressData[owner];
        uint256 auxCasted;
        // Cast `aux` with assembly to avoid redundant masking.
        assembly {
            auxCasted := aux
        }
        packed = (packed & _BITMASK_AUX_COMPLEMENT) | (auxCasted << _BITPOS_AUX);
        _packedAddressData[owner] = packed;
    }

    // =============================================================
    //                            IERC165
    // =============================================================

    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30000 gas.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        // The interface IDs are constants representing the first 4 bytes
        // of the XOR of all function selectors in the interface.
        // See: [ERC165](https://eips.ethereum.org/EIPS/eip-165)
        // (e.g. `bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)`)
        return
            interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165.
            interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.
            interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.
    }

    // =============================================================
    //                        IERC721Metadata
    // =============================================================

    /**
     * @dev Returns the token collection name.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

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

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

    // =============================================================
    //                     OWNERSHIPS OPERATIONS
    // =============================================================

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        return address(uint160(_packedOwnershipOf(tokenId)));
    }

    /**
     * @dev Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around over time.
     */
    function _ownershipOf(uint256 tokenId) internal view virtual returns (TokenOwnership memory) {
        return _unpackedOwnership(_packedOwnershipOf(tokenId));
    }

    /**
     * @dev Returns the unpacked `TokenOwnership` struct at `index`.
     */
    function _ownershipAt(uint256 index) internal view virtual returns (TokenOwnership memory) {
        return _unpackedOwnership(_packedOwnerships[index]);
    }

    /**
     * @dev Initializes the ownership slot minted at `index` for efficiency purposes.
     */
    function _initializeOwnershipAt(uint256 index) internal virtual {
        if (_packedOwnerships[index] == 0) {
            _packedOwnerships[index] = _packedOwnershipOf(index);
        }
    }

    /**
     * Returns the packed ownership data of `tokenId`.
     */
    function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr)
                if (curr < _currentIndex) {
                    uint256 packed = _packedOwnerships[curr];
                    // If not burned.
                    if (packed & _BITMASK_BURNED == 0) {
                        // Invariant:
                        // There will always be an initialized ownership slot
                        // (i.e. `ownership.addr != address(0) && ownership.burned == false`)
                        // before an unintialized ownership slot
                        // (i.e. `ownership.addr == address(0) && ownership.burned == false`)
                        // Hence, `curr` will not underflow.
                        //
                        // We can directly compare the packed value.
                        // If the address is zero, packed will be zero.
                        while (packed == 0) {
                            packed = _packedOwnerships[--curr];
                        }
                        return packed;
                    }
                }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * @dev Returns the unpacked `TokenOwnership` struct from `packed`.
     */
    function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
        ownership.addr = address(uint160(packed));
        ownership.startTimestamp = uint64(packed >> _BITPOS_START_TIMESTAMP);
        ownership.burned = packed & _BITMASK_BURNED != 0;
        ownership.extraData = uint24(packed >> _BITPOS_EXTRA_DATA);
    }

    /**
     * @dev Packs ownership data into a single uint256.
     */
    function _packOwnershipData(address owner, uint256 flags) private view returns (uint256 result) {
        assembly {
            // Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
            owner := and(owner, _BITMASK_ADDRESS)
            // `owner | (block.timestamp << _BITPOS_START_TIMESTAMP) | flags`.
            result := or(owner, or(shl(_BITPOS_START_TIMESTAMP, timestamp()), flags))
        }
    }

    /**
     * @dev Returns the `nextInitialized` flag set if `quantity` equals 1.
     */
    function _nextInitializedFlag(uint256 quantity) private pure returns (uint256 result) {
        // For branchless setting of the `nextInitialized` flag.
        assembly {
            // `(quantity == 1) << _BITPOS_NEXT_INITIALIZED`.
            result := shl(_BITPOS_NEXT_INITIALIZED, eq(quantity, 1))
        }
    }

    // =============================================================
    //                      APPROVAL OPERATIONS
    // =============================================================

    /**
     * @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) public payable virtual override {
        address owner = ownerOf(tokenId);

        if (_msgSenderERC721A() != owner)
            if (!isApprovedForAll(owner, _msgSenderERC721A())) {
                revert ApprovalCallerNotOwnerNorApproved();
            }

        _tokenApprovals[tokenId].value = to;
        emit Approval(owner, to, tokenId);
    }

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId].value;
    }

    /**
     * @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) public virtual override {
        _operatorApprovals[_msgSenderERC721A()][operator] = approved;
        emit ApprovalForAll(_msgSenderERC721A(), operator, approved);
    }

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

    /**
     * @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. See {_mint}.
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return
            _startTokenId() <= tokenId &&
            tokenId < _currentIndex && // If within bounds,
            _packedOwnerships[tokenId] & _BITMASK_BURNED == 0; // and not burned.
    }

    /**
     * @dev Returns whether `msgSender` is equal to `approvedAddress` or `owner`.
     */
    function _isSenderApprovedOrOwner(
        address approvedAddress,
        address owner,
        address msgSender
    ) private pure returns (bool result) {
        assembly {
            // Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
            owner := and(owner, _BITMASK_ADDRESS)
            // Mask `msgSender` to the lower 160 bits, in case the upper bits somehow aren't clean.
            msgSender := and(msgSender, _BITMASK_ADDRESS)
            // `msgSender == owner || msgSender == approvedAddress`.
            result := or(eq(msgSender, owner), eq(msgSender, approvedAddress))
        }
    }

    /**
     * @dev Returns the storage slot and value for the approved address of `tokenId`.
     */
    function _getApprovedSlotAndAddress(uint256 tokenId)
        private
        view
        returns (uint256 approvedAddressSlot, address approvedAddress)
    {
        TokenApprovalRef storage tokenApproval = _tokenApprovals[tokenId];
        // The following is equivalent to `approvedAddress = _tokenApprovals[tokenId].value`.
        assembly {
            approvedAddressSlot := tokenApproval.slot
            approvedAddress := sload(approvedAddressSlot)
        }
    }

    // =============================================================
    //                      TRANSFER OPERATIONS
    // =============================================================

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * 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
    ) public payable virtual override {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

        if (address(uint160(prevOwnershipPacked)) != from) revert TransferFromIncorrectOwner();

        (uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);

        // The nested ifs save around 20+ gas over a compound boolean condition.
        if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
            if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();

        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner.
        assembly {
            if approvedAddress {
                // This is equivalent to `delete _tokenApprovals[tokenId]`.
                sstore(approvedAddressSlot, 0)
            }
        }

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

            // Updates:
            // - `address` to the next owner.
            // - `startTimestamp` to the timestamp of transfering.
            // - `burned` to `false`.
            // - `nextInitialized` to `true`.
            _packedOwnerships[tokenId] = _packOwnershipData(
                to,
                _BITMASK_NEXT_INITIALIZED | _nextExtraData(from, to, prevOwnershipPacked)
            );

            // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
            if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
                uint256 nextTokenId = tokenId + 1;
                // If the next slot's address is zero and not burned (i.e. packed value is zero).
                if (_packedOwnerships[nextTokenId] == 0) {
                    // If the next slot is within bounds.
                    if (nextTokenId != _currentIndex) {
                        // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                        _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                    }
                }
            }
        }

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

    /**
     * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public payable virtual override {
        safeTransferFrom(from, to, tokenId, '');
    }

    /**
     * @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 memory _data
    ) public payable virtual override {
        transferFrom(from, to, tokenId);
        if (to.code.length != 0)
            if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
                revert TransferToNonERC721ReceiverImplementer();
            }
    }

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

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

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

    // =============================================================
    //                        MINT OPERATIONS
    // =============================================================

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event for each mint.
     */
    function _mint(address to, uint256 quantity) internal virtual {
        uint256 startTokenId = _currentIndex;
        if (quantity == 0) revert MintZeroQuantity();

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

        // Overflows are incredibly unrealistic.
        // `balance` and `numberMinted` have a maximum limit of 2**64.
        // `tokenId` has a maximum limit of 2**256.
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the `balance` and `numberMinted`.
            _packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);

            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            _packedOwnerships[startTokenId] = _packOwnershipData(
                to,
                _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
            );

            uint256 toMasked;
            uint256 end = startTokenId + quantity;

            // Use assembly to loop and emit the `Transfer` event for gas savings.
            // The duplicated `log4` removes an extra check and reduces stack juggling.
            // The assembly, together with the surrounding Solidity code, have been
            // delicately arranged to nudge the compiler into producing optimized opcodes.
            assembly {
                // Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
                toMasked := and(to, _BITMASK_ADDRESS)
                // Emit the `Transfer` event.
                log4(
                    0, // Start of data (0, since no data).
                    0, // End of data (0, since no data).
                    _TRANSFER_EVENT_SIGNATURE, // Signature.
                    0, // `address(0)`.
                    toMasked, // `to`.
                    startTokenId // `tokenId`.
                )

                // The `iszero(eq(,))` check ensures that large values of `quantity`
                // that overflows uint256 will make the loop run out of gas.
                // The compiler will optimize the `iszero` away for performance.
                for {
                    let tokenId := add(startTokenId, 1)
                } iszero(eq(tokenId, end)) {
                    tokenId := add(tokenId, 1)
                } {
                    // Emit the `Transfer` event. Similar to above.
                    log4(0, 0, _TRANSFER_EVENT_SIGNATURE, 0, toMasked, tokenId)
                }
            }
            if (toMasked == 0) revert MintToZeroAddress();

            _currentIndex = end;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * This function is intended for efficient minting only during contract creation.
     *
     * It emits only one {ConsecutiveTransfer} as defined in
     * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),
     * instead of a sequence of {Transfer} event(s).
     *
     * Calling this function outside of contract creation WILL make your contract
     * non-compliant with the ERC721 standard.
     * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309
     * {ConsecutiveTransfer} event is only permissible during contract creation.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {ConsecutiveTransfer} event.
     */
    function _mintERC2309(address to, uint256 quantity) internal virtual {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();
        if (quantity > _MAX_MINT_ERC2309_QUANTITY_LIMIT) revert MintERC2309QuantityExceedsLimit();

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

        // Overflows are unrealistic due to the above check for `quantity` to be below the limit.
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the `balance` and `numberMinted`.
            _packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);

            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            _packedOwnerships[startTokenId] = _packOwnershipData(
                to,
                _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
            );

            emit ConsecutiveTransfer(startTokenId, startTokenId + quantity - 1, address(0), to);

            _currentIndex = startTokenId + quantity;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement
     * {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * See {_mint}.
     *
     * Emits a {Transfer} event for each mint.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal virtual {
        _mint(to, quantity);

        unchecked {
            if (to.code.length != 0) {
                uint256 end = _currentIndex;
                uint256 index = end - quantity;
                do {
                    if (!_checkContractOnERC721Received(address(0), to, index++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (index < end);
                // Reentrancy protection.
                if (_currentIndex != end) revert();
            }
        }
    }

    /**
     * @dev Equivalent to `_safeMint(to, quantity, '')`.
     */
    function _safeMint(address to, uint256 quantity) internal virtual {
        _safeMint(to, quantity, '');
    }

    // =============================================================
    //                        BURN OPERATIONS
    // =============================================================

    /**
     * @dev Equivalent to `_burn(tokenId, false)`.
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

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

        address from = address(uint160(prevOwnershipPacked));

        (uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);

        if (approvalCheck) {
            // The nested ifs save around 20+ gas over a compound boolean condition.
            if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
                if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();
        }

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

        // Clear approvals from the previous owner.
        assembly {
            if approvedAddress {
                // This is equivalent to `delete _tokenApprovals[tokenId]`.
                sstore(approvedAddressSlot, 0)
            }
        }

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as `tokenId` would have to be 2**256.
        unchecked {
            // Updates:
            // - `balance -= 1`.
            // - `numberBurned += 1`.
            //
            // We can directly decrement the balance, and increment the number burned.
            // This is equivalent to `packed -= 1; packed += 1 << _BITPOS_NUMBER_BURNED;`.
            _packedAddressData[from] += (1 << _BITPOS_NUMBER_BURNED) - 1;

            // Updates:
            // - `address` to the last owner.
            // - `startTimestamp` to the timestamp of burning.
            // - `burned` to `true`.
            // - `nextInitialized` to `true`.
            _packedOwnerships[tokenId] = _packOwnershipData(
                from,
                (_BITMASK_BURNED | _BITMASK_NEXT_INITIALIZED) | _nextExtraData(from, address(0), prevOwnershipPacked)
            );

            // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
            if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
                uint256 nextTokenId = tokenId + 1;
                // If the next slot's address is zero and not burned (i.e. packed value is zero).
                if (_packedOwnerships[nextTokenId] == 0) {
                    // If the next slot is within bounds.
                    if (nextTokenId != _currentIndex) {
                        // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                        _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                    }
                }
            }
        }

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

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

    // =============================================================
    //                     EXTRA DATA OPERATIONS
    // =============================================================

    /**
     * @dev Directly sets the extra data for the ownership data `index`.
     */
    function _setExtraDataAt(uint256 index, uint24 extraData) internal virtual {
        uint256 packed = _packedOwnerships[index];
        if (packed == 0) revert OwnershipNotInitializedForExtraData();
        uint256 extraDataCasted;
        // Cast `extraData` with assembly to avoid redundant masking.
        assembly {
            extraDataCasted := extraData
        }
        packed = (packed & _BITMASK_EXTRA_DATA_COMPLEMENT) | (extraDataCasted << _BITPOS_EXTRA_DATA);
        _packedOwnerships[index] = packed;
    }

    /**
     * @dev Called during each token transfer to set the 24bit `extraData` field.
     * Intended to be overridden by the cosumer contract.
     *
     * `previousExtraData` - the value of `extraData` before transfer.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _extraData(
        address from,
        address to,
        uint24 previousExtraData
    ) internal view virtual returns (uint24) {}

    /**
     * @dev Returns the next extra data for the packed ownership data.
     * The returned result is shifted into position.
     */
    function _nextExtraData(
        address from,
        address to,
        uint256 prevOwnershipPacked
    ) private view returns (uint256) {
        uint24 extraData = uint24(prevOwnershipPacked >> _BITPOS_EXTRA_DATA);
        return uint256(_extraData(from, to, extraData)) << _BITPOS_EXTRA_DATA;
    }

    // =============================================================
    //                       OTHER OPERATIONS
    // =============================================================

    /**
     * @dev Returns the message sender (defaults to `msg.sender`).
     *
     * If you are writing GSN compatible contracts, you need to override this function.
     */
    function _msgSenderERC721A() internal view virtual returns (address) {
        return msg.sender;
    }

    /**
     * @dev Converts a uint256 to its ASCII string decimal representation.
     */
    function _toString(uint256 value) internal pure virtual returns (string memory str) {
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit), but
            // we allocate 0xa0 bytes to keep the free memory pointer 32-byte word aligned.
            // We will need 1 word for the trailing zeros padding, 1 word for the length,
            // and 3 words for a maximum of 78 digits. Total: 5 * 0x20 = 0xa0.
            let m := add(mload(0x40), 0xa0)
            // Update the free memory pointer to allocate.
            mstore(0x40, m)
            // Assign the `str` to the end.
            str := sub(m, 0x20)
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end of the memory to calculate the length later.
            let end := str

            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            // prettier-ignore
            for { let temp := value } 1 {} {
                str := sub(str, 1)
                // Write the character to the pointer.
                // The ASCII index of the '0' character is 48.
                mstore8(str, add(48, mod(temp, 10)))
                // Keep dividing `temp` until zero.
                temp := div(temp, 10)
                // prettier-ignore
                if iszero(temp) { break }
            }

            let length := sub(end, str)
            // Move the pointer 32 bytes leftwards to make room for the length.
            str := sub(str, 0x20)
            // Store the length.
            mstore(str, length)
        }
    }
}

// File: erc721a/contracts/extensions/IERC721AQueryable.sol


// ERC721A Contracts v4.2.3
// Creator: Chiru Labs

pragma solidity ^0.8.4;


/**
 * @dev Interface of ERC721AQueryable.
 */
interface IERC721AQueryable is IERC721A {
    /**
     * Invalid query range (`start` >= `stop`).
     */
    error InvalidQueryRange();

    /**
     * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
     *
     * If the `tokenId` is out of bounds:
     *
     * - `addr = address(0)`
     * - `startTimestamp = 0`
     * - `burned = false`
     * - `extraData = 0`
     *
     * If the `tokenId` is burned:
     *
     * - `addr = <Address of owner before token was burned>`
     * - `startTimestamp = <Timestamp when token was burned>`
     * - `burned = true`
     * - `extraData = <Extra data when token was burned>`
     *
     * Otherwise:
     *
     * - `addr = <Address of owner>`
     * - `startTimestamp = <Timestamp of start of ownership>`
     * - `burned = false`
     * - `extraData = <Extra data at start of ownership>`
     */
    function explicitOwnershipOf(uint256 tokenId) external view returns (TokenOwnership memory);

    /**
     * @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
     * See {ERC721AQueryable-explicitOwnershipOf}
     */
    function explicitOwnershipsOf(uint256[] memory tokenIds) external view returns (TokenOwnership[] memory);

    /**
     * @dev Returns an array of token IDs owned by `owner`,
     * in the range [`start`, `stop`)
     * (i.e. `start <= tokenId < stop`).
     *
     * This function allows for tokens to be queried if the collection
     * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
     *
     * Requirements:
     *
     * - `start < stop`
     */
    function tokensOfOwnerIn(
        address owner,
        uint256 start,
        uint256 stop
    ) external view returns (uint256[] memory);

    /**
     * @dev Returns an array of token IDs owned by `owner`.
     *
     * This function scans the ownership mapping and is O(`totalSupply`) in complexity.
     * It is meant to be called off-chain.
     *
     * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
     * multiple smaller scans if the collection is large enough to cause
     * an out-of-gas error (10K collections should be fine).
     */
    function tokensOfOwner(address owner) external view returns (uint256[] memory);
}

// File: erc721a/contracts/extensions/ERC721AQueryable.sol


// ERC721A Contracts v4.2.3
// Creator: Chiru Labs

pragma solidity ^0.8.4;



/**
 * @title ERC721AQueryable.
 *
 * @dev ERC721A subclass with convenience query functions.
 */
abstract contract ERC721AQueryable is ERC721A, IERC721AQueryable {
    /**
     * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
     *
     * If the `tokenId` is out of bounds:
     *
     * - `addr = address(0)`
     * - `startTimestamp = 0`
     * - `burned = false`
     * - `extraData = 0`
     *
     * If the `tokenId` is burned:
     *
     * - `addr = <Address of owner before token was burned>`
     * - `startTimestamp = <Timestamp when token was burned>`
     * - `burned = true`
     * - `extraData = <Extra data when token was burned>`
     *
     * Otherwise:
     *
     * - `addr = <Address of owner>`
     * - `startTimestamp = <Timestamp of start of ownership>`
     * - `burned = false`
     * - `extraData = <Extra data at start of ownership>`
     */
    function explicitOwnershipOf(uint256 tokenId) public view virtual override returns (TokenOwnership memory) {
        TokenOwnership memory ownership;
        if (tokenId < _startTokenId() || tokenId >= _nextTokenId()) {
            return ownership;
        }
        ownership = _ownershipAt(tokenId);
        if (ownership.burned) {
            return ownership;
        }
        return _ownershipOf(tokenId);
    }

    /**
     * @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
     * See {ERC721AQueryable-explicitOwnershipOf}
     */
    function explicitOwnershipsOf(uint256[] calldata tokenIds)
        external
        view
        virtual
        override
        returns (TokenOwnership[] memory)
    {
        unchecked {
            uint256 tokenIdsLength = tokenIds.length;
            TokenOwnership[] memory ownerships = new TokenOwnership[](tokenIdsLength);
            for (uint256 i; i != tokenIdsLength; ++i) {
                ownerships[i] = explicitOwnershipOf(tokenIds[i]);
            }
            return ownerships;
        }
    }

    /**
     * @dev Returns an array of token IDs owned by `owner`,
     * in the range [`start`, `stop`)
     * (i.e. `start <= tokenId < stop`).
     *
     * This function allows for tokens to be queried if the collection
     * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
     *
     * Requirements:
     *
     * - `start < stop`
     */
    function tokensOfOwnerIn(
        address owner,
        uint256 start,
        uint256 stop
    ) external view virtual override returns (uint256[] memory) {
        unchecked {
            if (start >= stop) revert InvalidQueryRange();
            uint256 tokenIdsIdx;
            uint256 stopLimit = _nextTokenId();
            // Set `start = max(start, _startTokenId())`.
            if (start < _startTokenId()) {
                start = _startTokenId();
            }
            // Set `stop = min(stop, stopLimit)`.
            if (stop > stopLimit) {
                stop = stopLimit;
            }
            uint256 tokenIdsMaxLength = balanceOf(owner);
            // Set `tokenIdsMaxLength = min(balanceOf(owner), stop - start)`,
            // to cater for cases where `balanceOf(owner)` is too big.
            if (start < stop) {
                uint256 rangeLength = stop - start;
                if (rangeLength < tokenIdsMaxLength) {
                    tokenIdsMaxLength = rangeLength;
                }
            } else {
                tokenIdsMaxLength = 0;
            }
            uint256[] memory tokenIds = new uint256[](tokenIdsMaxLength);
            if (tokenIdsMaxLength == 0) {
                return tokenIds;
            }
            // We need to call `explicitOwnershipOf(start)`,
            // because the slot at `start` may not be initialized.
            TokenOwnership memory ownership = explicitOwnershipOf(start);
            address currOwnershipAddr;
            // If the starting slot exists (i.e. not burned), initialize `currOwnershipAddr`.
            // `ownership.address` will not be zero, as `start` is clamped to the valid token ID range.
            if (!ownership.burned) {
                currOwnershipAddr = ownership.addr;
            }
            for (uint256 i = start; i != stop && tokenIdsIdx != tokenIdsMaxLength; ++i) {
                ownership = _ownershipAt(i);
                if (ownership.burned) {
                    continue;
                }
                if (ownership.addr != address(0)) {
                    currOwnershipAddr = ownership.addr;
                }
                if (currOwnershipAddr == owner) {
                    tokenIds[tokenIdsIdx++] = i;
                }
            }
            // Downsize the array to fit.
            assembly {
                mstore(tokenIds, tokenIdsIdx)
            }
            return tokenIds;
        }
    }

    /**
     * @dev Returns an array of token IDs owned by `owner`.
     *
     * This function scans the ownership mapping and is O(`totalSupply`) in complexity.
     * It is meant to be called off-chain.
     *
     * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
     * multiple smaller scans if the collection is large enough to cause
     * an out-of-gas error (10K collections should be fine).
     */
    function tokensOfOwner(address owner) external view virtual override returns (uint256[] memory) {
        unchecked {
            uint256 tokenIdsIdx;
            address currOwnershipAddr;
            uint256 tokenIdsLength = balanceOf(owner);
            uint256[] memory tokenIds = new uint256[](tokenIdsLength);
            TokenOwnership memory ownership;
            for (uint256 i = _startTokenId(); tokenIdsIdx != tokenIdsLength; ++i) {
                ownership = _ownershipAt(i);
                if (ownership.burned) {
                    continue;
                }
                if (ownership.addr != address(0)) {
                    currOwnershipAddr = ownership.addr;
                }
                if (currOwnershipAddr == owner) {
                    tokenIds[tokenIdsIdx++] = i;
                }
            }
            return tokenIds;
        }
    }
}

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.8.0) (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() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

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

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


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

pragma solidity ^0.8.0;

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

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

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

// File: contracts/lmb.sol



pragma solidity ^0.8.13;







contract LMBTHENOISE is Ownable, ReentrancyGuard, ERC721AQueryable, OperatorFilterer {
    using Strings for uint256;
    using ECDSA for bytes32;

    // Addresses
    address public sender = 0xA65aae78EdEF916d4102BA7b5672068C0D35fbff;

    // Sales configs
    uint256 public maxPerAddress;
    uint256 public primaryRoyalties;
    uint256 public startAt = 1681835250;
    uint256 public endAt = 1682737199;

    // Metadata uris
    string public baseURI;

    // State variables
    bool public paused = false;
    
    constructor(
        string memory _baseURI,
        string memory name,
        string memory symbol,
        uint256 _maxPerAddress
    ) ERC721A(name, symbol) OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), false) {
        // Set variables
        baseURI = _baseURI;
        maxPerAddress = _maxPerAddress;
    }

    modifier onlySender() {
        require((msg.sender == sender) || (msg.sender == owner()), "Only sender can use giveaway function.");
        _;
    }

    function mint(uint256 quantity, address to) external payable {
        require(block.timestamp >= startAt && block.timestamp <= endAt, "Purchase window closed.");
        require(quantity + _numberMinted(to) <= maxPerAddress, "User already minted max per address");
        require(!paused, "Contract is paused for minting.");
       
        _mint(to, quantity);
    }

    function giveaway(address to,  uint256 quantity) external onlySender {
        _mint(to, quantity);
    }

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

        return baseURI;
    }

    function setBaseURI(string calldata _baseURI) external onlyOwner {
        baseURI = _baseURI;
    }
    
    function setPause(bool _state) external onlyOwner {
        paused = _state;
    }

    function setMax(uint256 _maxPerAddress) external onlyOwner {
        maxPerAddress = _maxPerAddress;
    }

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

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

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

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"string","name":"_baseURI","type":"string"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint256","name":"_maxPerAddress","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"InvalidQueryRange","type":"error"},{"inputs":[],"name":"MintERC2309QuantityExceedsLimit","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"OwnershipNotInitializedForExtraData","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"fromTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"toTokenId","type":"uint256"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"ConsecutiveTransfer","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":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"endAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"explicitOwnershipOf","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint64","name":"startTimestamp","type":"uint64"},{"internalType":"bool","name":"burned","type":"bool"},{"internalType":"uint24","name":"extraData","type":"uint24"}],"internalType":"struct IERC721A.TokenOwnership","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"explicitOwnershipsOf","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint64","name":"startTimestamp","type":"uint64"},{"internalType":"bool","name":"burned","type":"bool"},{"internalType":"uint24","name":"extraData","type":"uint24"}],"internalType":"struct IERC721A.TokenOwnership[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"giveaway","outputs":[],"stateMutability":"nonpayable","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":"maxPerAddress","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"primaryRoyalties","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"payable","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":"payable","type":"function"},{"inputs":[],"name":"sender","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxPerAddress","type":"uint256"}],"name":"setMax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setPause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"stop","type":"uint256"}],"name":"tokensOfOwnerIn","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":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000004b68747470733a2f2f636f72652d6974656d732d696d616765732e73332e616d617a6f6e6177732e636f6d2f6c756d786274672f6d65746164617461732f6e6f2d72657665616c2e6a736f6e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e4c4d423a20544845204e4f49534500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000085448454e4f495345000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _baseURI (string): https://core-items-images.s3.amazonaws.com/lumxbtg/metadatas/no-reveal.json
Arg [1] : name (string): LMB: THE NOISE
Arg [2] : symbol (string): THENOISE
Arg [3] : _maxPerAddress (uint256): 1

-----Encoded View---------------
12 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000140
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [4] : 000000000000000000000000000000000000000000000000000000000000004b
Arg [5] : 68747470733a2f2f636f72652d6974656d732d696d616765732e73332e616d61
Arg [6] : 7a6f6e6177732e636f6d2f6c756d786274672f6d65746164617461732f6e6f2d
Arg [7] : 72657665616c2e6a736f6e000000000000000000000000000000000000000000
Arg [8] : 000000000000000000000000000000000000000000000000000000000000000e
Arg [9] : 4c4d423a20544845204e4f495345000000000000000000000000000000000000
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [11] : 5448454e4f495345000000000000000000000000000000000000000000000000


Deployed Bytecode Sourcemap

101297:2771:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52678:639;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;102740:107;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53580:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60071:218;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59504:408;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49331:323;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;101603:31;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;103304:108;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;103420:196;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;7735:143;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;103624:204;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;103098:102;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;89901:528;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;101801:26;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54973:152;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;101568:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;101471:66;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;101747:21;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50515:233;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;100406:103;;;;;;;;;;;;;:::i;:::-;;101683:33;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;93777:900;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;99758:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;102357:375;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53756:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;90817:2513;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60629:234;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;103836:229;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;103212:84;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;89314:428;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;101641:35;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;102855:235;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61020:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;100664:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52678:639;52763:4;53102:10;53087:25;;:11;:25;;;;:102;;;;53179:10;53164:25;;:11;:25;;;;53087:102;:179;;;;53256:10;53241:25;;:11;:25;;;;53087:179;53067:199;;52678:639;;;:::o;102740:107::-;102252:6;;;;;;;;;;;102238:20;;:10;:20;;;102237:49;;;;102278:7;:5;:7::i;:::-;102264:21;;:10;:21;;;102237:49;102229:100;;;;;;;;;;;;:::i;:::-;;;;;;;;;102820:19:::1;102826:2;102830:8;102820:5;:19::i;:::-;102740:107:::0;;:::o;53580:100::-;53634:13;53667:5;53660:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53580:100;:::o;60071:218::-;60147:7;60172:16;60180:7;60172;:16::i;:::-;60167:64;;60197:34;;;;;;;;;;;;;;60167:64;60251:15;:24;60267:7;60251:24;;;;;;;;;;;:30;;;;;;;;;;;;60244:37;;60071:218;;;:::o;59504:408::-;59593:13;59609:16;59617:7;59609;:16::i;:::-;59593:32;;59665:5;59642:28;;:19;:17;:19::i;:::-;:28;;;59638:175;;59690:44;59707:5;59714:19;:17;:19::i;:::-;59690:16;:44::i;:::-;59685:128;;59762:35;;;;;;;;;;;;;;59685:128;59638:175;59858:2;59825:15;:24;59841:7;59825:24;;;;;;;;;;;:30;;;:35;;;;;;;;;;;;;;;;;;59896:7;59892:2;59876:28;;59885:5;59876:28;;;;;;;;;;;;59582:330;59504:408;;:::o;49331:323::-;49392:7;49620:15;:13;:15::i;:::-;49605:12;;49589:13;;:28;:46;49582:53;;49331:323;:::o;101603:31::-;;;;:::o;103304:108::-;99644:13;:11;:13::i;:::-;103390:14:::1;103374:13;:30;;;;103304:108:::0;:::o;103420:196::-;103549:4;9251:10;9243:18;;:4;:18;;;9239:83;;9278:32;9299:10;9278:20;:32::i;:::-;9239:83;103571:37:::1;103590:4;103596:2;103600:7;103571:18;:37::i;:::-;103420:196:::0;;;;:::o;7735:143::-;151:42;7735:143;:::o;103624:204::-;103757:4;9251:10;9243:18;;:4;:18;;;9239:83;;9278:32;9299:10;9278:20;:32::i;:::-;9239:83;103779:41:::1;103802:4;103808:2;103812:7;103779:22;:41::i;:::-;103624:204:::0;;;;:::o;103098:102::-;99644:13;:11;:13::i;:::-;103184:8:::1;;103174:7;:18;;;;;;;:::i;:::-;;103098:102:::0;;:::o;89901:528::-;90045:23;90111:22;90136:8;;:15;;90111:40;;90166:34;90224:14;90203:36;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;90166:73;;90259:9;90254:125;90275:14;90270:1;:19;90254:125;;90331:32;90351:8;;90360:1;90351:11;;;;;;;:::i;:::-;;;;;;;;90331:19;:32::i;:::-;90315:10;90326:1;90315:13;;;;;;;;:::i;:::-;;;;;;;:48;;;;90291:3;;;;;90254:125;;;;90400:10;90393:17;;;;89901:528;;;;:::o;101801:26::-;;;;;;;;;;;;;:::o;54973:152::-;55045:7;55088:27;55107:7;55088:18;:27::i;:::-;55065:52;;54973:152;;;:::o;101568:28::-;;;;:::o;101471:66::-;;;;;;;;;;;;;:::o;101747:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;50515:233::-;50587:7;50628:1;50611:19;;:5;:19;;;50607:60;;50639:28;;;;;;;;;;;;;;50607:60;44674:13;50685:18;:25;50704:5;50685:25;;;;;;;;;;;;;;;;:55;50678:62;;50515:233;;;:::o;100406:103::-;99644:13;:11;:13::i;:::-;100471:30:::1;100498:1;100471:18;:30::i;:::-;100406:103::o:0;101683:33::-;;;;:::o;93777:900::-;93855:16;93909:19;93943:25;93983:22;94008:16;94018:5;94008:9;:16::i;:::-;93983:41;;94039:25;94081:14;94067:29;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94039:57;;94111:31;;:::i;:::-;94162:9;94174:15;:13;:15::i;:::-;94162:27;;94157:472;94206:14;94191:11;:29;94157:472;;94258:15;94271:1;94258:12;:15::i;:::-;94246:27;;94296:9;:16;;;94337:8;94292:73;94413:1;94387:28;;:9;:14;;;:28;;;94383:111;;94460:9;:14;;;94440:34;;94383:111;94537:5;94516:26;;:17;:26;;;94512:102;;94593:1;94567:8;94576:13;;;;;;94567:23;;;;;;;;:::i;:::-;;;;;;;:27;;;;;94512:102;94157:472;94222:3;;;;;94157:472;;;;94650:8;94643:15;;;;;;;93777:900;;;:::o;99758:87::-;99804:7;99831:6;;;;;;;;;;;99824:13;;99758:87;:::o;102357:375::-;102456:7;;102437:15;:26;;:54;;;;;102486:5;;102467:15;:24;;102437:54;102429:90;;;;;;;;;;;;:::i;:::-;;;;;;;;;102570:13;;102549:17;102563:2;102549:13;:17::i;:::-;102538:8;:28;;;;:::i;:::-;:45;;102530:93;;;;;;;;;;;;:::i;:::-;;;;;;;;;102643:6;;;;;;;;;;;102642:7;102634:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;102705:19;102711:2;102715:8;102705:5;:19::i;:::-;102357:375;;:::o;53756:104::-;53812:13;53845:7;53838:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53756:104;:::o;90817:2513::-;90960:16;91027:4;91018:5;:13;91014:45;;91040:19;;;;;;;;;;;;;;91014:45;91074:19;91108:17;91128:14;:12;:14::i;:::-;91108:34;;91228:15;:13;:15::i;:::-;91220:5;:23;91216:87;;;91272:15;:13;:15::i;:::-;91264:23;;91216:87;91379:9;91372:4;:16;91368:73;;;91416:9;91409:16;;91368:73;91455:25;91483:16;91493:5;91483:9;:16::i;:::-;91455:44;;91677:4;91669:5;:12;91665:278;;;91702:19;91731:5;91724:4;:12;91702:34;;91773:17;91759:11;:31;91755:111;;;91835:11;91815:31;;91755:111;91683:198;91665:278;;;91926:1;91906:21;;91665:278;91957:25;91999:17;91985:32;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;91957:60;;92057:1;92036:17;:22;92032:78;;92086:8;92079:15;;;;;;;;92032:78;92254:31;92288:26;92308:5;92288:19;:26::i;:::-;92254:60;;92329:25;92574:9;:16;;;92569:92;;92631:9;:14;;;92611:34;;92569:92;92680:9;92692:5;92680:17;;92675:478;92704:4;92699:1;:9;;:45;;;;;92727:17;92712:11;:32;;92699:45;92675:478;;;92782:15;92795:1;92782:12;:15::i;:::-;92770:27;;92820:9;:16;;;92861:8;92816:73;92937:1;92911:28;;:9;:14;;;:28;;;92907:111;;92984:9;:14;;;92964:34;;92907:111;93061:5;93040:26;;:17;:26;;;93036:102;;93117:1;93091:8;93100:13;;;;;;93091:23;;;;;;;;:::i;:::-;;;;;;;:27;;;;;93036:102;92675:478;92746:3;;;;;92675:478;;;;93255:11;93245:8;93238:29;93303:8;93296:15;;;;;;;;90817:2513;;;;;;:::o;60629:234::-;60776:8;60724:18;:39;60743:19;:17;:19::i;:::-;60724:39;;;;;;;;;;;;;;;:49;60764:8;60724:49;;;;;;;;;;;;;;;;:60;;;;;;;;;;;;;;;;;;60836:8;60800:55;;60815:19;:17;:19::i;:::-;60800:55;;;60846:8;60800:55;;;;;;:::i;:::-;;;;;;;;60629:234;;:::o;103836:229::-;103988:4;9251:10;9243:18;;:4;:18;;;9239:83;;9278:32;9299:10;9278:20;:32::i;:::-;9239:83;104010:47:::1;104033:4;104039:2;104043:7;104052:4;104010:22;:47::i;:::-;103836:229:::0;;;;;:::o;103212:84::-;99644:13;:11;:13::i;:::-;103282:6:::1;103273;;:15;;;;;;;;;;;;;;;;;;103212:84:::0;:::o;89314:428::-;89398:21;;:::i;:::-;89432:31;;:::i;:::-;89488:15;:13;:15::i;:::-;89478:7;:25;:54;;;;89518:14;:12;:14::i;:::-;89507:7;:25;;89478:54;89474:103;;;89556:9;89549:16;;;;;89474:103;89599:21;89612:7;89599:12;:21::i;:::-;89587:33;;89635:9;:16;;;89631:65;;;89675:9;89668:16;;;;;89631:65;89713:21;89726:7;89713:12;:21::i;:::-;89706:28;;;89314:428;;;;:::o;101641:35::-;;;;:::o;102855:235::-;102948:13;102982:16;102990:7;102982;:16::i;:::-;102974:77;;;;;;;;;;;;:::i;:::-;;;;;;;;;103075:7;103068:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;102855:235;;;:::o;61020:164::-;61117:4;61141:18;:25;61160:5;61141:25;;;;;;;;;;;;;;;:35;61167:8;61141:35;;;;;;;;;;;;;;;;;;;;;;;;;61134:42;;61020:164;;;;:::o;100664:201::-;99644:13;:11;:13::i;:::-;100773:1:::1;100753:22;;:8;:22;;::::0;100745:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;100829:28;100848:8;100829:18;:28::i;:::-;100664:201:::0;:::o;71091:2966::-;71164:20;71187:13;;71164:36;;71227:1;71215:8;:13;71211:44;;71237:18;;;;;;;;;;;;;;71211:44;71268:61;71298:1;71302:2;71306:12;71320:8;71268:21;:61::i;:::-;71812:1;44812:2;71782:1;:26;;71781:32;71769:8;:45;71743:18;:22;71762:2;71743:22;;;;;;;;;;;;;;;;:71;;;;;;;;;;;72091:139;72128:2;72182:33;72205:1;72209:2;72213:1;72182:14;:33::i;:::-;72149:30;72170:8;72149:20;:30::i;:::-;:66;72091:18;:139::i;:::-;72057:17;:31;72075:12;72057:31;;;;;;;;;;;:173;;;;72247:16;72278:11;72307:8;72292:12;:23;72278:37;;72828:16;72824:2;72820:25;72808:37;;73200:12;73160:8;73119:1;73057:25;72998:1;72937;72910:335;73571:1;73557:12;73553:20;73511:346;73612:3;73603:7;73600:16;73511:346;;73830:7;73820:8;73817:1;73790:25;73787:1;73784;73779:59;73665:1;73656:7;73652:15;73641:26;;73511:346;;;73515:77;73902:1;73890:8;:13;73886:45;;73912:19;;;;;;;;;;;;;;73886:45;73964:3;73948:13;:19;;;;71517:2462;;73989:60;74018:1;74022:2;74026:12;74040:8;73989:20;:60::i;:::-;71153:2904;71091:2966;;:::o;61442:282::-;61507:4;61563:7;61544:15;:13;:15::i;:::-;:26;;:66;;;;;61597:13;;61587:7;:23;61544:66;:153;;;;;61696:1;45450:8;61648:17;:26;61666:7;61648:26;;;;;;;;;;;;:44;:49;61544:153;61524:173;;61442:282;;;:::o;83750:105::-;83810:7;83837:10;83830:17;;83750:105;:::o;48847:92::-;48903:7;48847:92;:::o;99923:132::-;99998:12;:10;:12::i;:::-;99987:23;;:7;:5;:7::i;:::-;:23;;;99979:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;99923:132::o;9660:647::-;9899:1;151:42;9851:45;;;:49;9847:453;;;151:42;10150;;;10201:4;10208:8;10150:67;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10145:144;;10264:8;10245:28;;;;;;;;;;;:::i;:::-;;;;;;;;10145:144;9847:453;9660:647;:::o;63710:2825::-;63852:27;63882;63901:7;63882:18;:27::i;:::-;63852:57;;63967:4;63926:45;;63942:19;63926:45;;;63922:86;;63980:28;;;;;;;;;;;;;;63922:86;64022:27;64051:23;64078:35;64105:7;64078:26;:35::i;:::-;64021:92;;;;64213:68;64238:15;64255:4;64261:19;:17;:19::i;:::-;64213:24;:68::i;:::-;64208:180;;64301:43;64318:4;64324:19;:17;:19::i;:::-;64301:16;:43::i;:::-;64296:92;;64353:35;;;;;;;;;;;;;;64296:92;64208:180;64419:1;64405:16;;:2;:16;;;64401:52;;64430:23;;;;;;;;;;;;;;64401:52;64466:43;64488:4;64494:2;64498:7;64507:1;64466:21;:43::i;:::-;64602:15;64599:160;;;64742:1;64721:19;64714:30;64599:160;65139:18;:24;65158:4;65139:24;;;;;;;;;;;;;;;;65137:26;;;;;;;;;;;;65208:18;:22;65227:2;65208:22;;;;;;;;;;;;;;;;65206:24;;;;;;;;;;;65530:146;65567:2;65616:45;65631:4;65637:2;65641:19;65616:14;:45::i;:::-;45730:8;65588:73;65530:18;:146::i;:::-;65501:17;:26;65519:7;65501:26;;;;;;;;;;;:175;;;;65847:1;45730:8;65796:19;:47;:52;65792:627;;65869:19;65901:1;65891:7;:11;65869:33;;66058:1;66024:17;:30;66042:11;66024:30;;;;;;;;;;;;:35;66020:384;;66162:13;;66147:11;:28;66143:242;;66342:19;66309:17;:30;66327:11;66309:30;;;;;;;;;;;:52;;;;66143:242;66020:384;65850:569;65792:627;66466:7;66462:2;66447:27;;66456:4;66447:27;;;;;;;;;;;;66485:42;66506:4;66512:2;66516:7;66525:1;66485:20;:42::i;:::-;63841:2694;;;63710:2825;;;:::o;66631:193::-;66777:39;66794:4;66800:2;66804:7;66777:39;;;;;;;;;;;;:16;:39::i;:::-;66631:193;;;:::o;56128:1275::-;56195:7;56215:12;56230:7;56215:22;;56298:4;56279:15;:13;:15::i;:::-;:23;56275:1061;;56332:13;;56325:4;:20;56321:1015;;;56370:14;56387:17;:23;56405:4;56387:23;;;;;;;;;;;;56370:40;;56504:1;45450:8;56476:6;:24;:29;56472:845;;57141:113;57158:1;57148:6;:11;57141:113;;57201:17;:25;57219:6;;;;;;;57201:25;;;;;;;;;;;;57192:34;;57141:113;;;57287:6;57280:13;;;;;;56472:845;56347:989;56321:1015;56275:1061;57364:31;;;;;;;;;;;;;;56128:1275;;;;:::o;101025:191::-;101099:16;101118:6;;;;;;;;;;;101099:25;;101144:8;101135:6;;:17;;;;;;;;;;;;;;;;;;101199:8;101168:40;;101189:8;101168:40;;;;;;;;;;;;101088:128;101025:191;:::o;55576:161::-;55644:21;;:::i;:::-;55685:44;55704:17;:24;55722:5;55704:24;;;;;;;;;;;;55685:18;:44::i;:::-;55678:51;;55576:161;;;:::o;50830:178::-;50891:7;44674:13;44812:2;50919:18;:25;50938:5;50919:25;;;;;;;;;;;;;;;;:50;;50918:82;50911:89;;50830:178;;;:::o;49018:103::-;49073:7;49100:13;;49093:20;;49018:103;:::o;67422:407::-;67597:31;67610:4;67616:2;67620:7;67597:12;:31::i;:::-;67661:1;67643:2;:14;;;:19;67639:183;;67682:56;67713:4;67719:2;67723:7;67732:5;67682:30;:56::i;:::-;67677:145;;67766:40;;;;;;;;;;;;;;67677:145;67639:183;67422:407;;;;:::o;55314:166::-;55384:21;;:::i;:::-;55425:47;55444:27;55463:7;55444:18;:27::i;:::-;55425:18;:47::i;:::-;55418:54;;55314:166;;;:::o;68491:159::-;;;;;:::o;83059:311::-;83194:7;83214:16;45854:3;83240:19;:41;;83214:68;;45854:3;83308:31;83319:4;83325:2;83329:9;83308:10;:31::i;:::-;83300:40;;:62;;83293:69;;;83059:311;;;;;:::o;58503:324::-;58573:14;58806:1;58796:8;58793:15;58767:24;58763:46;58753:56;;58503:324;;;:::o;57951:450::-;58031:14;58199:16;58192:5;58188:28;58179:37;;58376:5;58362:11;58337:23;58333:41;58330:52;58323:5;58320:63;58310:73;;57951:450;;;;:::o;69315:158::-;;;;;:::o;98309:98::-;98362:7;98389:10;98382:17;;98309:98;:::o;62605:485::-;62707:27;62736:23;62777:38;62818:15;:24;62834:7;62818:24;;;;;;;;;;;62777:65;;62995:18;62972:41;;63052:19;63046:26;63027:45;;62957:126;62605:485;;;:::o;61833:659::-;61982:11;62147:16;62140:5;62136:28;62127:37;;62307:16;62296:9;62292:32;62279:45;;62457:15;62446:9;62443:30;62435:5;62424:9;62421:20;62418:56;62408:66;;61833:659;;;;;:::o;57502:366::-;57568:31;;:::i;:::-;57645:6;57612:9;:14;;:41;;;;;;;;;;;45333:3;57698:6;:33;;57664:9;:24;;:68;;;;;;;;;;;57790:1;45450:8;57762:6;:24;:29;;57743:9;:16;;:48;;;;;;;;;;;45854:3;57831:6;:28;;57802:9;:19;;:58;;;;;;;;;;;57502:366;;;:::o;69913:716::-;70076:4;70122:2;70097:45;;;70143:19;:17;:19::i;:::-;70164:4;70170:7;70179:5;70097:88;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;70093:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70397:1;70380:6;:13;:18;70376:235;;70426:40;;;;;;;;;;;;;;70376:235;70569:6;70563:13;70554:6;70550:2;70546:15;70539:38;70093:529;70266:54;;;70256:64;;;:6;:64;;;;70249:71;;;69913:716;;;;;;:::o;82760:147::-;82897:6;82760:147;;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:126::-;1555:7;1595:42;1588:5;1584:54;1573:65;;1518:126;;;:::o;1650:96::-;1687:7;1716:24;1734:5;1716:24;:::i;:::-;1705:35;;1650:96;;;:::o;1752:122::-;1825:24;1843:5;1825:24;:::i;:::-;1818:5;1815:35;1805:63;;1864:1;1861;1854:12;1805:63;1752:122;:::o;1880:139::-;1926:5;1964:6;1951:20;1942:29;;1980:33;2007:5;1980:33;:::i;:::-;1880:139;;;;:::o;2025:77::-;2062:7;2091:5;2080:16;;2025:77;;;:::o;2108:122::-;2181:24;2199:5;2181:24;:::i;:::-;2174:5;2171:35;2161:63;;2220:1;2217;2210:12;2161:63;2108:122;:::o;2236:139::-;2282:5;2320:6;2307:20;2298:29;;2336:33;2363:5;2336:33;:::i;:::-;2236:139;;;;:::o;2381:474::-;2449:6;2457;2506:2;2494:9;2485:7;2481:23;2477:32;2474:119;;;2512:79;;:::i;:::-;2474:119;2632:1;2657:53;2702:7;2693:6;2682:9;2678:22;2657:53;:::i;:::-;2647:63;;2603:117;2759:2;2785:53;2830:7;2821:6;2810:9;2806:22;2785:53;:::i;:::-;2775:63;;2730:118;2381:474;;;;;:::o;2861:99::-;2913:6;2947:5;2941:12;2931:22;;2861:99;;;:::o;2966:169::-;3050:11;3084:6;3079:3;3072:19;3124:4;3119:3;3115:14;3100:29;;2966:169;;;;:::o;3141:307::-;3209:1;3219:113;3233:6;3230:1;3227:13;3219:113;;;3318:1;3313:3;3309:11;3303:18;3299:1;3294:3;3290:11;3283:39;3255:2;3252:1;3248:10;3243:15;;3219:113;;;3350:6;3347:1;3344:13;3341:101;;;3430:1;3421:6;3416:3;3412:16;3405:27;3341:101;3190:258;3141:307;;;:::o;3454:102::-;3495:6;3546:2;3542:7;3537:2;3530:5;3526:14;3522:28;3512:38;;3454:102;;;:::o;3562:364::-;3650:3;3678:39;3711:5;3678:39;:::i;:::-;3733:71;3797:6;3792:3;3733:71;:::i;:::-;3726:78;;3813:52;3858:6;3853:3;3846:4;3839:5;3835:16;3813:52;:::i;:::-;3890:29;3912:6;3890:29;:::i;:::-;3885:3;3881:39;3874:46;;3654:272;3562:364;;;;:::o;3932:313::-;4045:4;4083:2;4072:9;4068:18;4060:26;;4132:9;4126:4;4122:20;4118:1;4107:9;4103:17;4096:47;4160:78;4233:4;4224:6;4160:78;:::i;:::-;4152:86;;3932:313;;;;:::o;4251:329::-;4310:6;4359:2;4347:9;4338:7;4334:23;4330:32;4327:119;;;4365:79;;:::i;:::-;4327:119;4485:1;4510:53;4555:7;4546:6;4535:9;4531:22;4510:53;:::i;:::-;4500:63;;4456:117;4251:329;;;;:::o;4586:118::-;4673:24;4691:5;4673:24;:::i;:::-;4668:3;4661:37;4586:118;;:::o;4710:222::-;4803:4;4841:2;4830:9;4826:18;4818:26;;4854:71;4922:1;4911:9;4907:17;4898:6;4854:71;:::i;:::-;4710:222;;;;:::o;4938:118::-;5025:24;5043:5;5025:24;:::i;:::-;5020:3;5013:37;4938:118;;:::o;5062:222::-;5155:4;5193:2;5182:9;5178:18;5170:26;;5206:71;5274:1;5263:9;5259:17;5250:6;5206:71;:::i;:::-;5062:222;;;;:::o;5290:619::-;5367:6;5375;5383;5432:2;5420:9;5411:7;5407:23;5403:32;5400:119;;;5438:79;;:::i;:::-;5400:119;5558:1;5583:53;5628:7;5619:6;5608:9;5604:22;5583:53;:::i;:::-;5573:63;;5529:117;5685:2;5711:53;5756:7;5747:6;5736:9;5732:22;5711:53;:::i;:::-;5701:63;;5656:118;5813:2;5839:53;5884:7;5875:6;5864:9;5860:22;5839:53;:::i;:::-;5829:63;;5784:118;5290:619;;;;;:::o;5915:60::-;5943:3;5964:5;5957:12;;5915:60;;;:::o;5981:142::-;6031:9;6064:53;6082:34;6091:24;6109:5;6091:24;:::i;:::-;6082:34;:::i;:::-;6064:53;:::i;:::-;6051:66;;5981:142;;;:::o;6129:126::-;6179:9;6212:37;6243:5;6212:37;:::i;:::-;6199:50;;6129:126;;;:::o;6261:157::-;6342:9;6375:37;6406:5;6375:37;:::i;:::-;6362:50;;6261:157;;;:::o;6424:193::-;6542:68;6604:5;6542:68;:::i;:::-;6537:3;6530:81;6424:193;;:::o;6623:284::-;6747:4;6785:2;6774:9;6770:18;6762:26;;6798:102;6897:1;6886:9;6882:17;6873:6;6798:102;:::i;:::-;6623:284;;;;:::o;6913:117::-;7022:1;7019;7012:12;7036:117;7145:1;7142;7135:12;7159:117;7268:1;7265;7258:12;7296:553;7354:8;7364:6;7414:3;7407:4;7399:6;7395:17;7391:27;7381:122;;7422:79;;:::i;:::-;7381:122;7535:6;7522:20;7512:30;;7565:18;7557:6;7554:30;7551:117;;;7587:79;;:::i;:::-;7551:117;7701:4;7693:6;7689:17;7677:29;;7755:3;7747:4;7739:6;7735:17;7725:8;7721:32;7718:41;7715:128;;;7762:79;;:::i;:::-;7715:128;7296:553;;;;;:::o;7855:529::-;7926:6;7934;7983:2;7971:9;7962:7;7958:23;7954:32;7951:119;;;7989:79;;:::i;:::-;7951:119;8137:1;8126:9;8122:17;8109:31;8167:18;8159:6;8156:30;8153:117;;;8189:79;;:::i;:::-;8153:117;8302:65;8359:7;8350:6;8339:9;8335:22;8302:65;:::i;:::-;8284:83;;;;8080:297;7855:529;;;;;:::o;8407:568::-;8480:8;8490:6;8540:3;8533:4;8525:6;8521:17;8517:27;8507:122;;8548:79;;:::i;:::-;8507:122;8661:6;8648:20;8638:30;;8691:18;8683:6;8680:30;8677:117;;;8713:79;;:::i;:::-;8677:117;8827:4;8819:6;8815:17;8803:29;;8881:3;8873:4;8865:6;8861:17;8851:8;8847:32;8844:41;8841:128;;;8888:79;;:::i;:::-;8841:128;8407:568;;;;;:::o;8981:559::-;9067:6;9075;9124:2;9112:9;9103:7;9099:23;9095:32;9092:119;;;9130:79;;:::i;:::-;9092:119;9278:1;9267:9;9263:17;9250:31;9308:18;9300:6;9297:30;9294:117;;;9330:79;;:::i;:::-;9294:117;9443:80;9515:7;9506:6;9495:9;9491:22;9443:80;:::i;:::-;9425:98;;;;9221:312;8981:559;;;;;:::o;9546:146::-;9645:6;9679:5;9673:12;9663:22;;9546:146;;;:::o;9698:216::-;9829:11;9863:6;9858:3;9851:19;9903:4;9898:3;9894:14;9879:29;;9698:216;;;;:::o;9920:164::-;10019:4;10042:3;10034:11;;10072:4;10067:3;10063:14;10055:22;;9920:164;;;:::o;10090:108::-;10167:24;10185:5;10167:24;:::i;:::-;10162:3;10155:37;10090:108;;:::o;10204:101::-;10240:7;10280:18;10273:5;10269:30;10258:41;;10204:101;;;:::o;10311:105::-;10386:23;10403:5;10386:23;:::i;:::-;10381:3;10374:36;10311:105;;:::o;10422:99::-;10493:21;10508:5;10493:21;:::i;:::-;10488:3;10481:34;10422:99;;:::o;10527:91::-;10563:7;10603:8;10596:5;10592:20;10581:31;;10527:91;;;:::o;10624:105::-;10699:23;10716:5;10699:23;:::i;:::-;10694:3;10687:36;10624:105;;:::o;10807:866::-;10958:4;10953:3;10949:14;11045:4;11038:5;11034:16;11028:23;11064:63;11121:4;11116:3;11112:14;11098:12;11064:63;:::i;:::-;10973:164;11229:4;11222:5;11218:16;11212:23;11248:61;11303:4;11298:3;11294:14;11280:12;11248:61;:::i;:::-;11147:172;11403:4;11396:5;11392:16;11386:23;11422:57;11473:4;11468:3;11464:14;11450:12;11422:57;:::i;:::-;11329:160;11576:4;11569:5;11565:16;11559:23;11595:61;11650:4;11645:3;11641:14;11627:12;11595:61;:::i;:::-;11499:167;10927:746;10807:866;;:::o;11679:307::-;11812:10;11833:110;11939:3;11931:6;11833:110;:::i;:::-;11975:4;11970:3;11966:14;11952:28;;11679:307;;;;:::o;11992:145::-;12094:4;12126;12121:3;12117:14;12109:22;;11992:145;;;:::o;12219:988::-;12402:3;12431:86;12511:5;12431:86;:::i;:::-;12533:118;12644:6;12639:3;12533:118;:::i;:::-;12526:125;;12675:88;12757:5;12675:88;:::i;:::-;12786:7;12817:1;12802:380;12827:6;12824:1;12821:13;12802:380;;;12903:6;12897:13;12930:127;13053:3;13038:13;12930:127;:::i;:::-;12923:134;;13080:92;13165:6;13080:92;:::i;:::-;13070:102;;12862:320;12849:1;12846;12842:9;12837:14;;12802:380;;;12806:14;13198:3;13191:10;;12407:800;;;12219:988;;;;:::o;13213:501::-;13420:4;13458:2;13447:9;13443:18;13435:26;;13507:9;13501:4;13497:20;13493:1;13482:9;13478:17;13471:47;13535:172;13702:4;13693:6;13535:172;:::i;:::-;13527:180;;13213:501;;;;:::o;13720:329::-;13779:6;13828:2;13816:9;13807:7;13803:23;13799:32;13796:119;;;13834:79;;:::i;:::-;13796:119;13954:1;13979:53;14024:7;14015:6;14004:9;14000:22;13979:53;:::i;:::-;13969:63;;13925:117;13720:329;;;;:::o;14055:114::-;14122:6;14156:5;14150:12;14140:22;;14055:114;;;:::o;14175:184::-;14274:11;14308:6;14303:3;14296:19;14348:4;14343:3;14339:14;14324:29;;14175:184;;;;:::o;14365:132::-;14432:4;14455:3;14447:11;;14485:4;14480:3;14476:14;14468:22;;14365:132;;;:::o;14503:108::-;14580:24;14598:5;14580:24;:::i;:::-;14575:3;14568:37;14503:108;;:::o;14617:179::-;14686:10;14707:46;14749:3;14741:6;14707:46;:::i;:::-;14785:4;14780:3;14776:14;14762:28;;14617:179;;;;:::o;14802:113::-;14872:4;14904;14899:3;14895:14;14887:22;;14802:113;;;:::o;14951:732::-;15070:3;15099:54;15147:5;15099:54;:::i;:::-;15169:86;15248:6;15243:3;15169:86;:::i;:::-;15162:93;;15279:56;15329:5;15279:56;:::i;:::-;15358:7;15389:1;15374:284;15399:6;15396:1;15393:13;15374:284;;;15475:6;15469:13;15502:63;15561:3;15546:13;15502:63;:::i;:::-;15495:70;;15588:60;15641:6;15588:60;:::i;:::-;15578:70;;15434:224;15421:1;15418;15414:9;15409:14;;15374:284;;;15378:14;15674:3;15667:10;;15075:608;;;14951:732;;;;:::o;15689:373::-;15832:4;15870:2;15859:9;15855:18;15847:26;;15919:9;15913:4;15909:20;15905:1;15894:9;15890:17;15883:47;15947:108;16050:4;16041:6;15947:108;:::i;:::-;15939:116;;15689:373;;;;:::o;16068:474::-;16136:6;16144;16193:2;16181:9;16172:7;16168:23;16164:32;16161:119;;;16199:79;;:::i;:::-;16161:119;16319:1;16344:53;16389:7;16380:6;16369:9;16365:22;16344:53;:::i;:::-;16334:63;;16290:117;16446:2;16472:53;16517:7;16508:6;16497:9;16493:22;16472:53;:::i;:::-;16462:63;;16417:118;16068:474;;;;;:::o;16548:619::-;16625:6;16633;16641;16690:2;16678:9;16669:7;16665:23;16661:32;16658:119;;;16696:79;;:::i;:::-;16658:119;16816:1;16841:53;16886:7;16877:6;16866:9;16862:22;16841:53;:::i;:::-;16831:63;;16787:117;16943:2;16969:53;17014:7;17005:6;16994:9;16990:22;16969:53;:::i;:::-;16959:63;;16914:118;17071:2;17097:53;17142:7;17133:6;17122:9;17118:22;17097:53;:::i;:::-;17087:63;;17042:118;16548:619;;;;;:::o;17173:116::-;17243:21;17258:5;17243:21;:::i;:::-;17236:5;17233:32;17223:60;;17279:1;17276;17269:12;17223:60;17173:116;:::o;17295:133::-;17338:5;17376:6;17363:20;17354:29;;17392:30;17416:5;17392:30;:::i;:::-;17295:133;;;;:::o;17434:468::-;17499:6;17507;17556:2;17544:9;17535:7;17531:23;17527:32;17524:119;;;17562:79;;:::i;:::-;17524:119;17682:1;17707:53;17752:7;17743:6;17732:9;17728:22;17707:53;:::i;:::-;17697:63;;17653:117;17809:2;17835:50;17877:7;17868:6;17857:9;17853:22;17835:50;:::i;:::-;17825:60;;17780:115;17434:468;;;;;:::o;17908:117::-;18017:1;18014;18007:12;18031:180;18079:77;18076:1;18069:88;18176:4;18173:1;18166:15;18200:4;18197:1;18190:15;18217:281;18300:27;18322:4;18300:27;:::i;:::-;18292:6;18288:40;18430:6;18418:10;18415:22;18394:18;18382:10;18379:34;18376:62;18373:88;;;18441:18;;:::i;:::-;18373:88;18481:10;18477:2;18470:22;18260:238;18217:281;;:::o;18504:129::-;18538:6;18565:20;;:::i;:::-;18555:30;;18594:33;18622:4;18614:6;18594:33;:::i;:::-;18504:129;;;:::o;18639:307::-;18700:4;18790:18;18782:6;18779:30;18776:56;;;18812:18;;:::i;:::-;18776:56;18850:29;18872:6;18850:29;:::i;:::-;18842:37;;18934:4;18928;18924:15;18916:23;;18639:307;;;:::o;18952:154::-;19036:6;19031:3;19026;19013:30;19098:1;19089:6;19084:3;19080:16;19073:27;18952:154;;;:::o;19112:410::-;19189:5;19214:65;19230:48;19271:6;19230:48;:::i;:::-;19214:65;:::i;:::-;19205:74;;19302:6;19295:5;19288:21;19340:4;19333:5;19329:16;19378:3;19369:6;19364:3;19360:16;19357:25;19354:112;;;19385:79;;:::i;:::-;19354:112;19475:41;19509:6;19504:3;19499;19475:41;:::i;:::-;19195:327;19112:410;;;;;:::o;19541:338::-;19596:5;19645:3;19638:4;19630:6;19626:17;19622:27;19612:122;;19653:79;;:::i;:::-;19612:122;19770:6;19757:20;19795:78;19869:3;19861:6;19854:4;19846:6;19842:17;19795:78;:::i;:::-;19786:87;;19602:277;19541:338;;;;:::o;19885:943::-;19980:6;19988;19996;20004;20053:3;20041:9;20032:7;20028:23;20024:33;20021:120;;;20060:79;;:::i;:::-;20021:120;20180:1;20205:53;20250:7;20241:6;20230:9;20226:22;20205:53;:::i;:::-;20195:63;;20151:117;20307:2;20333:53;20378:7;20369:6;20358:9;20354:22;20333:53;:::i;:::-;20323:63;;20278:118;20435:2;20461:53;20506:7;20497:6;20486:9;20482:22;20461:53;:::i;:::-;20451:63;;20406:118;20591:2;20580:9;20576:18;20563:32;20622:18;20614:6;20611:30;20608:117;;;20644:79;;:::i;:::-;20608:117;20749:62;20803:7;20794:6;20783:9;20779:22;20749:62;:::i;:::-;20739:72;;20534:287;19885:943;;;;;;;:::o;20834:323::-;20890:6;20939:2;20927:9;20918:7;20914:23;20910:32;20907:119;;;20945:79;;:::i;:::-;20907:119;21065:1;21090:50;21132:7;21123:6;21112:9;21108:22;21090:50;:::i;:::-;21080:60;;21036:114;20834:323;;;;:::o;21235:876::-;21396:4;21391:3;21387:14;21483:4;21476:5;21472:16;21466:23;21502:63;21559:4;21554:3;21550:14;21536:12;21502:63;:::i;:::-;21411:164;21667:4;21660:5;21656:16;21650:23;21686:61;21741:4;21736:3;21732:14;21718:12;21686:61;:::i;:::-;21585:172;21841:4;21834:5;21830:16;21824:23;21860:57;21911:4;21906:3;21902:14;21888:12;21860:57;:::i;:::-;21767:160;22014:4;22007:5;22003:16;21997:23;22033:61;22088:4;22083:3;22079:14;22065:12;22033:61;:::i;:::-;21937:167;21365:746;21235:876;;:::o;22117:351::-;22274:4;22312:3;22301:9;22297:19;22289:27;;22326:135;22458:1;22447:9;22443:17;22434:6;22326:135;:::i;:::-;22117:351;;;;:::o;22474:474::-;22542:6;22550;22599:2;22587:9;22578:7;22574:23;22570:32;22567:119;;;22605:79;;:::i;:::-;22567:119;22725:1;22750:53;22795:7;22786:6;22775:9;22771:22;22750:53;:::i;:::-;22740:63;;22696:117;22852:2;22878:53;22923:7;22914:6;22903:9;22899:22;22878:53;:::i;:::-;22868:63;;22823:118;22474:474;;;;;:::o;22954:225::-;23094:34;23090:1;23082:6;23078:14;23071:58;23163:8;23158:2;23150:6;23146:15;23139:33;22954:225;:::o;23185:366::-;23327:3;23348:67;23412:2;23407:3;23348:67;:::i;:::-;23341:74;;23424:93;23513:3;23424:93;:::i;:::-;23542:2;23537:3;23533:12;23526:19;;23185:366;;;:::o;23557:419::-;23723:4;23761:2;23750:9;23746:18;23738:26;;23810:9;23804:4;23800:20;23796:1;23785:9;23781:17;23774:47;23838:131;23964:4;23838:131;:::i;:::-;23830:139;;23557:419;;;:::o;23982:180::-;24030:77;24027:1;24020:88;24127:4;24124:1;24117:15;24151:4;24148:1;24141:15;24168:320;24212:6;24249:1;24243:4;24239:12;24229:22;;24296:1;24290:4;24286:12;24317:18;24307:81;;24373:4;24365:6;24361:17;24351:27;;24307:81;24435:2;24427:6;24424:14;24404:18;24401:38;24398:84;;24454:18;;:::i;:::-;24398:84;24219:269;24168:320;;;:::o;24494:180::-;24542:77;24539:1;24532:88;24639:4;24636:1;24629:15;24663:4;24660:1;24653:15;24680:173;24820:25;24816:1;24808:6;24804:14;24797:49;24680:173;:::o;24859:366::-;25001:3;25022:67;25086:2;25081:3;25022:67;:::i;:::-;25015:74;;25098:93;25187:3;25098:93;:::i;:::-;25216:2;25211:3;25207:12;25200:19;;24859:366;;;:::o;25231:419::-;25397:4;25435:2;25424:9;25420:18;25412:26;;25484:9;25478:4;25474:20;25470:1;25459:9;25455:17;25448:47;25512:131;25638:4;25512:131;:::i;:::-;25504:139;;25231:419;;;:::o;25656:180::-;25704:77;25701:1;25694:88;25801:4;25798:1;25791:15;25825:4;25822:1;25815:15;25842:305;25882:3;25901:20;25919:1;25901:20;:::i;:::-;25896:25;;25935:20;25953:1;25935:20;:::i;:::-;25930:25;;26089:1;26021:66;26017:74;26014:1;26011:81;26008:107;;;26095:18;;:::i;:::-;26008:107;26139:1;26136;26132:9;26125:16;;25842:305;;;;:::o;26153:222::-;26293:34;26289:1;26281:6;26277:14;26270:58;26362:5;26357:2;26349:6;26345:15;26338:30;26153:222;:::o;26381:366::-;26523:3;26544:67;26608:2;26603:3;26544:67;:::i;:::-;26537:74;;26620:93;26709:3;26620:93;:::i;:::-;26738:2;26733:3;26729:12;26722:19;;26381:366;;;:::o;26753:419::-;26919:4;26957:2;26946:9;26942:18;26934:26;;27006:9;27000:4;26996:20;26992:1;26981:9;26977:17;26970:47;27034:131;27160:4;27034:131;:::i;:::-;27026:139;;26753:419;;;:::o;27178:181::-;27318:33;27314:1;27306:6;27302:14;27295:57;27178:181;:::o;27365:366::-;27507:3;27528:67;27592:2;27587:3;27528:67;:::i;:::-;27521:74;;27604:93;27693:3;27604:93;:::i;:::-;27722:2;27717:3;27713:12;27706:19;;27365:366;;;:::o;27737:419::-;27903:4;27941:2;27930:9;27926:18;27918:26;;27990:9;27984:4;27980:20;27976:1;27965:9;27961:17;27954:47;28018:131;28144:4;28018:131;:::i;:::-;28010:139;;27737:419;;;:::o;28162:235::-;28302:34;28298:1;28290:6;28286:14;28279:58;28371:18;28366:2;28358:6;28354:15;28347:43;28162:235;:::o;28403:366::-;28545:3;28566:67;28630:2;28625:3;28566:67;:::i;:::-;28559:74;;28642:93;28731:3;28642:93;:::i;:::-;28760:2;28755:3;28751:12;28744:19;;28403:366;;;:::o;28775:419::-;28941:4;28979:2;28968:9;28964:18;28956:26;;29028:9;29022:4;29018:20;29014:1;29003:9;28999:17;28992:47;29056:131;29182:4;29056:131;:::i;:::-;29048:139;;28775:419;;;:::o;29200:225::-;29340:34;29336:1;29328:6;29324:14;29317:58;29409:8;29404:2;29396:6;29392:15;29385:33;29200:225;:::o;29431:366::-;29573:3;29594:67;29658:2;29653:3;29594:67;:::i;:::-;29587:74;;29670:93;29759:3;29670:93;:::i;:::-;29788:2;29783:3;29779:12;29772:19;;29431:366;;;:::o;29803:419::-;29969:4;30007:2;29996:9;29992:18;29984:26;;30056:9;30050:4;30046:20;30042:1;30031:9;30027:17;30020:47;30084:131;30210:4;30084:131;:::i;:::-;30076:139;;29803:419;;;:::o;30228:182::-;30368:34;30364:1;30356:6;30352:14;30345:58;30228:182;:::o;30416:366::-;30558:3;30579:67;30643:2;30638:3;30579:67;:::i;:::-;30572:74;;30655:93;30744:3;30655:93;:::i;:::-;30773:2;30768:3;30764:12;30757:19;;30416:366;;;:::o;30788:419::-;30954:4;30992:2;30981:9;30977:18;30969:26;;31041:9;31035:4;31031:20;31027:1;31016:9;31012:17;31005:47;31069:131;31195:4;31069:131;:::i;:::-;31061:139;;30788:419;;;:::o;31213:332::-;31334:4;31372:2;31361:9;31357:18;31349:26;;31385:71;31453:1;31442:9;31438:17;31429:6;31385:71;:::i;:::-;31466:72;31534:2;31523:9;31519:18;31510:6;31466:72;:::i;:::-;31213:332;;;;;:::o;31551:137::-;31605:5;31636:6;31630:13;31621:22;;31652:30;31676:5;31652:30;:::i;:::-;31551:137;;;;:::o;31694:345::-;31761:6;31810:2;31798:9;31789:7;31785:23;31781:32;31778:119;;;31816:79;;:::i;:::-;31778:119;31936:1;31961:61;32014:7;32005:6;31994:9;31990:22;31961:61;:::i;:::-;31951:71;;31907:125;31694:345;;;;:::o;32045:98::-;32096:6;32130:5;32124:12;32114:22;;32045:98;;;:::o;32149:168::-;32232:11;32266:6;32261:3;32254:19;32306:4;32301:3;32297:14;32282:29;;32149:168;;;;:::o;32323:360::-;32409:3;32437:38;32469:5;32437:38;:::i;:::-;32491:70;32554:6;32549:3;32491:70;:::i;:::-;32484:77;;32570:52;32615:6;32610:3;32603:4;32596:5;32592:16;32570:52;:::i;:::-;32647:29;32669:6;32647:29;:::i;:::-;32642:3;32638:39;32631:46;;32413:270;32323:360;;;;:::o;32689:640::-;32884:4;32922:3;32911:9;32907:19;32899:27;;32936:71;33004:1;32993:9;32989:17;32980:6;32936:71;:::i;:::-;33017:72;33085:2;33074:9;33070:18;33061:6;33017:72;:::i;:::-;33099;33167:2;33156:9;33152:18;33143:6;33099:72;:::i;:::-;33218:9;33212:4;33208:20;33203:2;33192:9;33188:18;33181:48;33246:76;33317:4;33308:6;33246:76;:::i;:::-;33238:84;;32689:640;;;;;;;:::o;33335:141::-;33391:5;33422:6;33416:13;33407:22;;33438:32;33464:5;33438:32;:::i;:::-;33335:141;;;;:::o;33482:349::-;33551:6;33600:2;33588:9;33579:7;33575:23;33571:32;33568:119;;;33606:79;;:::i;:::-;33568:119;33726:1;33751:63;33806:7;33797:6;33786:9;33782:22;33751:63;:::i;:::-;33741:73;;33697:127;33482:349;;;;:::o

Swarm Source

ipfs://171c90f93dba0c86b6b2785e874ea1e07607375c6145b82fcb540f7e5b3e0a2f
Loading...
Loading
[ Download: CSV Export  ]
[ Download: CSV Export  ]

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.