{"sources":{"Mindvolt.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.24;\n\n// File: @openzeppelin/contracts/utils/introspection/IERC165.sol\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)\n\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n\n// File: @openzeppelin/contracts/token/ERC721/IERC721.sol\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)\n\n\n\n/**\n * @dev Required interface of an ERC721 compliant contract.\n */\ninterface IERC721 is IERC165 {\n    /**\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n     */\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n     */\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    /**\n     * @dev Returns the number of tokens in ``owner``'s account.\n     */\n    function balanceOf(address owner) external view returns (uint256 balance);\n\n    /**\n     * @dev Returns the owner of the `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function ownerOf(uint256 tokenId) external view returns (address owner);\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n     *   a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n     * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or\n     *   {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n     *   a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Transfers `tokenId` token from `from` to `to`.\n     *\n     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721\n     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must\n     * understand this adds an external call which potentially creates a reentrancy vulnerability.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n     * The approval is cleared when the token is transferred.\n     *\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n     *\n     * Requirements:\n     *\n     * - The caller must own the token or be an approved operator.\n     * - `tokenId` must exist.\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address to, uint256 tokenId) external;\n\n    /**\n     * @dev Approve or remove `operator` as an operator for the caller.\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n     *\n     * Requirements:\n     *\n     * - The `operator` cannot be the address zero.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function setApprovalForAll(address operator, bool approved) external;\n\n    /**\n     * @dev Returns the account approved for `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function getApproved(uint256 tokenId) external view returns (address operator);\n\n    /**\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n     *\n     * See {setApprovalForAll}\n     */\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\n}\n\n// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)\n\n\n/**\n * @title ERC721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC721 asset contracts.\n */\ninterface IERC721Receiver {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be\n     * reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n\n// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)\n\n\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721Metadata is IERC721 {\n    /**\n     * @dev Returns the token collection name.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the token collection symbol.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n     */\n    function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n\n// File: @openzeppelin/contracts/utils/Context.sol\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n\n// File: @openzeppelin/contracts/utils/math/Math.sol\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)\n\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    /**\n     * @dev Muldiv operation overflow.\n     */\n    error MathOverflowedMulDiv();\n\n    enum Rounding {\n        Floor, // Toward negative infinity\n        Ceil, // Toward positive infinity\n        Trunc, // Toward zero\n        Expand // Away from zero\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, with an overflow flag.\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            uint256 c = a + b;\n            if (c < a) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b > a) return (false, 0);\n            return (true, a - b);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n            // benefit is lost if 'b' is also tested.\n            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n            if (a == 0) return (true, 0);\n            uint256 c = a * b;\n            if (c / a != b) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a division by zero flag.\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a / b);\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a % b);\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds towards infinity instead\n     * of rounding towards zero.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (b == 0) {\n            // Guarantee the same behavior as in a regular Solidity division.\n            return a / b;\n        }\n\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a == 0 ? 0 : (a - 1) / b + 1;\n    }\n\n    /**\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\n     * denominator == 0.\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\n     * Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2^256 + prod0.\n            uint256 prod0 = x * y; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            if (denominator <= prod1) {\n                revert MathOverflowedMulDiv();\n            }\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\n\n            uint256 twos = denominator & (0 - denominator);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv = 1 mod 2^4.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\n            // works in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        uint256 result = mulDiv(x, y, denominator);\n        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {\n            result += 1;\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\n     * towards zero.\n     *\n     * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        if (a == 0) {\n            return 0;\n        }\n\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n        //\n        // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n        //\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n        //\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n        uint256 result = 1 << (log2(a) >> 1);\n\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n        // into the expected uint128 result.\n        unchecked {\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            return min(result, a / result);\n        }\n    }\n\n    /**\n     * @notice Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 128;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 64;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 32;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 16;\n            }\n            if (value >> 8 > 0) {\n                value >>= 8;\n                result += 8;\n            }\n            if (value >> 4 > 0) {\n                value >>= 4;\n                result += 4;\n            }\n            if (value >> 2 > 0) {\n                value >>= 2;\n                result += 2;\n            }\n            if (value >> 1 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 16;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 8;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 4;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 2;\n            }\n            if (value >> 8 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\n     */\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\n        return uint8(rounding) % 2 == 1;\n    }\n}\n\n// File: @openzeppelin/contracts/utils/math/SignedMath.sol\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)\n\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // must be unchecked in order to support `n = type(int256).min`\n            return uint256(n >= 0 ? n : -n);\n        }\n    }\n}\n\n// File: @openzeppelin/contracts/utils/Strings.sol\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)\n\n\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    bytes16 private constant HEX_DIGITS = \"0123456789abcdef\";\n    uint8 private constant ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev The `value` string doesn't fit in the specified `length`.\n     */\n    error StringsInsufficientHexLength(uint256 value, uint256 length);\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            /// @solidity memory-safe-assembly\n            assembly {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toStringSigned(int256 value) internal pure returns (string memory) {\n        return string.concat(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value)));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        uint256 localValue = value;\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = HEX_DIGITS[localValue & 0xf];\n            localValue >>= 4;\n        }\n        if (localValue != 0) {\n            revert StringsInsufficientHexLength(value, length);\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\n     * representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n}\n\n// File: @openzeppelin/contracts/utils/introspection/ERC165.sol\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)\n\n\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165 is IERC165 {\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n\n// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)\n\n/**\n * @dev Standard ERC20 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.\n */\ninterface IERC20Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC20InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC20InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     * @param allowance Amount of tokens a `spender` is allowed to operate with.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC20InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC20InvalidSpender(address spender);\n}\n\n/**\n * @dev Standard ERC721 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.\n */\ninterface IERC721Errors {\n    /**\n     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.\n     * Used in balance queries.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721InvalidOwner(address owner);\n\n    /**\n     * @dev Indicates a `tokenId` whose `owner` is the zero address.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721NonexistentToken(uint256 tokenId);\n\n    /**\n     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param tokenId Identifier number of a token.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC721InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC721InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721InsufficientApproval(address operator, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC721InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC721InvalidOperator(address operator);\n}\n\n/**\n * @dev Standard ERC1155 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.\n */\ninterface IERC1155Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC1155InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC1155InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC1155MissingApprovalForAll(address operator, address owner);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC1155InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC1155InvalidOperator(address operator);\n\n    /**\n     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.\n     * Used in batch transfers.\n     * @param idsLength Length of the array of token identifiers\n     * @param valuesLength Length of the array of token amounts\n     */\n    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);\n}\n\n// File: @openzeppelin/contracts/token/ERC721/ERC721.sol\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/ERC721.sol)\n\n\n\n/**\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\n * {ERC721Enumerable}.\n */\nabstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {\n    using Strings for uint256;\n\n    // Token name\n    string private _name;\n\n    // Token symbol\n    string private _symbol;\n\n    mapping(uint256 tokenId => address) private _owners;\n\n    mapping(address owner => uint256) private _balances;\n\n    mapping(uint256 tokenId => address) private _tokenApprovals;\n\n    mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;\n\n    /**\n     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\n        return\n            interfaceId == type(IERC721).interfaceId ||\n            interfaceId == type(IERC721Metadata).interfaceId ||\n            super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev See {IERC721-balanceOf}.\n     */\n    function balanceOf(address owner) public view virtual returns (uint256) {\n        if (owner == address(0)) {\n            revert ERC721InvalidOwner(address(0));\n        }\n        return _balances[owner];\n    }\n\n    /**\n     * @dev See {IERC721-ownerOf}.\n     */\n    function ownerOf(uint256 tokenId) public view virtual returns (address) {\n        return _requireOwned(tokenId);\n    }\n\n    /**\n     * @dev See {IERC721Metadata-name}.\n     */\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev See {IERC721Metadata-symbol}.\n     */\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev See {IERC721Metadata-tokenURI}.\n     */\n    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {\n        _requireOwned(tokenId);\n\n        string memory baseURI = _baseURI();\n        return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : \"\";\n    }\n\n    /**\n     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\n     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\n     * by default, can be overridden in child contracts.\n     */\n    function _baseURI() internal view virtual returns (string memory) {\n        return \"\";\n    }\n\n    /**\n     * @dev See {IERC721-approve}.\n     */\n    function approve(address to, uint256 tokenId) public virtual {\n        _approve(to, tokenId, _msgSender());\n    }\n\n    /**\n     * @dev See {IERC721-getApproved}.\n     */\n    function getApproved(uint256 tokenId) public view virtual returns (address) {\n        _requireOwned(tokenId);\n\n        return _getApproved(tokenId);\n    }\n\n    /**\n     * @dev See {IERC721-setApprovalForAll}.\n     */\n    function setApprovalForAll(address operator, bool approved) public virtual {\n        _setApprovalForAll(_msgSender(), operator, approved);\n    }\n\n    /**\n     * @dev See {IERC721-isApprovedForAll}.\n     */\n    function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {\n        return _operatorApprovals[owner][operator];\n    }\n\n    /**\n     * @dev See {IERC721-transferFrom}.\n     */\n    function transferFrom(address from, address to, uint256 tokenId) public virtual {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        // Setting an \"auth\" arguments enables the `_isAuthorized` check which verifies that the token exists\n        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.\n        address previousOwner = _update(to, tokenId, _msgSender());\n        if (previousOwner != from) {\n            revert ERC721IncorrectOwner(from, tokenId, previousOwner);\n        }\n    }\n\n    /**\n     * @dev See {IERC721-safeTransferFrom}.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId) public {\n        safeTransferFrom(from, to, tokenId, \"\");\n    }\n\n    /**\n     * @dev See {IERC721-safeTransferFrom}.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {\n        transferFrom(from, to, tokenId);\n        _checkOnERC721Received(from, to, tokenId, data);\n    }\n\n    /**\n     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist\n     *\n     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the\n     * core ERC721 logic MUST be matched with the use of {_increaseBalance} to keep balances\n     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by\n     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.\n     */\n    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {\n        return _owners[tokenId];\n    }\n\n    /**\n     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.\n     */\n    function _getApproved(uint256 tokenId) internal view virtual returns (address) {\n        return _tokenApprovals[tokenId];\n    }\n\n    /**\n     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in\n     * particular (ignoring whether it is owned by `owner`).\n     *\n     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this\n     * assumption.\n     */\n    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {\n        return\n            spender != address(0) &&\n            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);\n    }\n\n    /**\n     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.\n     * Reverts if `spender` does not have approval from the provided `owner` for the given token or for all its assets\n     * the `spender` for the specific `tokenId`.\n     *\n     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this\n     * assumption.\n     */\n    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {\n        if (!_isAuthorized(owner, spender, tokenId)) {\n            if (owner == address(0)) {\n                revert ERC721NonexistentToken(tokenId);\n            } else {\n                revert ERC721InsufficientApproval(spender, tokenId);\n            }\n        }\n    }\n\n    /**\n     * @dev Unsafe write access to the balances, used by extensions that \"mint\" tokens using an {ownerOf} override.\n     *\n     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that\n     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.\n     *\n     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the\n     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership\n     * remain consistent with one another.\n     */\n    function _increaseBalance(address account, uint128 value) internal virtual {\n        unchecked {\n            _balances[account] += value;\n        }\n    }\n\n    /**\n     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner\n     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.\n     *\n     * The `auth` argument is optional. If the value passed is non 0, then this function will check that\n     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).\n     *\n     * Emits a {Transfer} event.\n     *\n     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.\n     */\n    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {\n        address from = _ownerOf(tokenId);\n\n        // Perform (optional) operator check\n        if (auth != address(0)) {\n            _checkAuthorized(from, auth, tokenId);\n        }\n\n        // Execute the update\n        if (from != address(0)) {\n            // Clear approval. No need to re-authorize or emit the Approval event\n            _approve(address(0), tokenId, address(0), false);\n\n            unchecked {\n                _balances[from] -= 1;\n            }\n        }\n\n        if (to != address(0)) {\n            unchecked {\n                _balances[to] += 1;\n            }\n        }\n\n        _owners[tokenId] = to;\n\n        emit Transfer(from, to, tokenId);\n\n        return from;\n    }\n\n    /**\n     * @dev Mints `tokenId` and transfers it to `to`.\n     *\n     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - `to` cannot be the zero address.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _mint(address to, uint256 tokenId) internal {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        address previousOwner = _update(to, tokenId, address(0));\n        if (previousOwner != address(0)) {\n            revert ERC721InvalidSender(address(0));\n        }\n    }\n\n    /**\n     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeMint(address to, uint256 tokenId) internal {\n        _safeMint(to, tokenId, \"\");\n    }\n\n    /**\n     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\n     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n     */\n    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {\n        _mint(to, tokenId);\n        _checkOnERC721Received(address(0), to, tokenId, data);\n    }\n\n    /**\n     * @dev Destroys `tokenId`.\n     * The approval is cleared when the token is burned.\n     * This is an internal function that does not check if the sender is authorized to operate on the token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _burn(uint256 tokenId) internal {\n        address previousOwner = _update(address(0), tokenId, address(0));\n        if (previousOwner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        }\n    }\n\n    /**\n     * @dev Transfers `tokenId` from `from` to `to`.\n     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _transfer(address from, address to, uint256 tokenId) internal {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        address previousOwner = _update(to, tokenId, address(0));\n        if (previousOwner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        } else if (previousOwner != from) {\n            revert ERC721IncorrectOwner(from, tokenId, previousOwner);\n        }\n    }\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients\n     * are aware of the ERC721 standard to prevent tokens from being forever locked.\n     *\n     * `data` is additional data, it has no specified format and it is sent in call to `to`.\n     *\n     * This internal function is like {safeTransferFrom} in the sense that it invokes\n     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.\n     * implement alternative mechanisms to perform token transfer, such as signature-based.\n     *\n     * Requirements:\n     *\n     * - `tokenId` token must exist and be owned by `from`.\n     * - `to` cannot be the zero address.\n     * - `from` cannot be the zero address.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeTransfer(address from, address to, uint256 tokenId) internal {\n        _safeTransfer(from, to, tokenId, \"\");\n    }\n\n    /**\n     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is\n     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n     */\n    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {\n        _transfer(from, to, tokenId);\n        _checkOnERC721Received(from, to, tokenId, data);\n    }\n\n    /**\n     * @dev Approve `to` to operate on `tokenId`\n     *\n     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is\n     * either the owner of the token, or approved to operate on all tokens held by this owner.\n     *\n     * Emits an {Approval} event.\n     *\n     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\n     */\n    function _approve(address to, uint256 tokenId, address auth) internal {\n        _approve(to, tokenId, auth, true);\n    }\n\n    /**\n     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not\n     * emitted in the context of transfers.\n     */\n    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {\n        // Avoid reading the owner unless necessary\n        if (emitEvent || auth != address(0)) {\n            address owner = _requireOwned(tokenId);\n\n            // We do not use _isAuthorized because single-token approvals should not be able to call approve\n            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {\n                revert ERC721InvalidApprover(auth);\n            }\n\n            if (emitEvent) {\n                emit Approval(owner, to, tokenId);\n            }\n        }\n\n        _tokenApprovals[tokenId] = to;\n    }\n\n    /**\n     * @dev Approve `operator` to operate on all of `owner` tokens\n     *\n     * Requirements:\n     * - operator can't be the address zero.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {\n        if (operator == address(0)) {\n            revert ERC721InvalidOperator(operator);\n        }\n        _operatorApprovals[owner][operator] = approved;\n        emit ApprovalForAll(owner, operator, approved);\n    }\n\n    /**\n     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).\n     * Returns the owner.\n     *\n     * Overrides to ownership logic should be done to {_ownerOf}.\n     */\n    function _requireOwned(uint256 tokenId) internal view returns (address) {\n        address owner = _ownerOf(tokenId);\n        if (owner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        }\n        return owner;\n    }\n\n    /**\n     * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target address. This will revert if the\n     * recipient doesn't accept the token transfer. The call is not executed if the target address is not a contract.\n     *\n     * @param from address representing the previous owner of the given token ID\n     * @param to target address that will receive the tokens\n     * @param tokenId uint256 ID of the token to be transferred\n     * @param data bytes optional data to send along with the call\n     */\n    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private {\n        if (to.code.length > 0) {\n            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {\n                if (retval != IERC721Receiver.onERC721Received.selector) {\n                    revert ERC721InvalidReceiver(to);\n                }\n            } catch (bytes memory reason) {\n                if (reason.length == 0) {\n                    revert ERC721InvalidReceiver(to);\n                } else {\n                    /// @solidity memory-safe-assembly\n                    assembly {\n                        revert(add(32, reason), mload(reason))\n                    }\n                }\n            }\n        }\n    }\n}\n\n// File: @openzeppelin/contracts/interfaces/IERC2981.sol\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC2981.sol)\n\n\n\n/**\n * @dev Interface for the NFT Royalty Standard.\n *\n * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal\n * support for royalty payments across all NFT marketplaces and ecosystem participants.\n */\ninterface IERC2981 is IERC165 {\n    /**\n     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of\n     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.\n     */\n    function royaltyInfo(\n        uint256 tokenId,\n        uint256 salePrice\n    ) external view returns (address receiver, uint256 royaltyAmount);\n}\n\n// File: @openzeppelin/contracts/token/common/ERC2981.sol\n// OpenZeppelin Contracts (last updated v5.0.0) (token/common/ERC2981.sol)\n\n\n\n/**\n * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.\n *\n * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for\n * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.\n *\n * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the\n * fee is specified in basis points by default.\n *\n * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See\n * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to\n * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.\n */\nabstract contract ERC2981 is IERC2981, ERC165 {\n    struct RoyaltyInfo {\n        address receiver;\n        uint96 royaltyFraction;\n    }\n\n    RoyaltyInfo private _defaultRoyaltyInfo;\n    mapping(uint256 tokenId => RoyaltyInfo) private _tokenRoyaltyInfo;\n\n    /**\n     * @dev The default royalty set is invalid (eg. (numerator / denominator) >= 1).\n     */\n    error ERC2981InvalidDefaultRoyalty(uint256 numerator, uint256 denominator);\n\n    /**\n     * @dev The default royalty receiver is invalid.\n     */\n    error ERC2981InvalidDefaultRoyaltyReceiver(address receiver);\n\n    /**\n     * @dev The royalty set for an specific `tokenId` is invalid (eg. (numerator / denominator) >= 1).\n     */\n    error ERC2981InvalidTokenRoyalty(uint256 tokenId, uint256 numerator, uint256 denominator);\n\n    /**\n     * @dev The royalty receiver for `tokenId` is invalid.\n     */\n    error ERC2981InvalidTokenRoyaltyReceiver(uint256 tokenId, address receiver);\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) {\n        return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @inheritdoc IERC2981\n     */\n    function royaltyInfo(uint256 tokenId, uint256 salePrice) public view virtual returns (address, uint256) {\n        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[tokenId];\n\n        if (royalty.receiver == address(0)) {\n            royalty = _defaultRoyaltyInfo;\n        }\n\n        uint256 royaltyAmount = (salePrice * royalty.royaltyFraction) / _feeDenominator();\n\n        return (royalty.receiver, royaltyAmount);\n    }\n\n    /**\n     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a\n     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an\n     * override.\n     */\n    function _feeDenominator() internal pure virtual returns (uint96) {\n        return 10000;\n    }\n\n    /**\n     * @dev Sets the royalty information that all ids in this contract will default to.\n     *\n     * Requirements:\n     *\n     * - `receiver` cannot be the zero address.\n     * - `feeNumerator` cannot be greater than the fee denominator.\n     */\n    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {\n        uint256 denominator = _feeDenominator();\n        if (feeNumerator > denominator) {\n            // Royalty fee will exceed the sale price\n            revert ERC2981InvalidDefaultRoyalty(feeNumerator, denominator);\n        }\n        if (receiver == address(0)) {\n            revert ERC2981InvalidDefaultRoyaltyReceiver(address(0));\n        }\n\n        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);\n    }\n\n    /**\n     * @dev Removes default royalty information.\n     */\n    function _deleteDefaultRoyalty() internal virtual {\n        delete _defaultRoyaltyInfo;\n    }\n\n    /**\n     * @dev Sets the royalty information for a specific token id, overriding the global default.\n     *\n     * Requirements:\n     *\n     * - `receiver` cannot be the zero address.\n     * - `feeNumerator` cannot be greater than the fee denominator.\n     */\n    function _setTokenRoyalty(uint256 tokenId, address receiver, uint96 feeNumerator) internal virtual {\n        uint256 denominator = _feeDenominator();\n        if (feeNumerator > denominator) {\n            // Royalty fee will exceed the sale price\n            revert ERC2981InvalidTokenRoyalty(tokenId, feeNumerator, denominator);\n        }\n        if (receiver == address(0)) {\n            revert ERC2981InvalidTokenRoyaltyReceiver(tokenId, address(0));\n        }\n\n        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);\n    }\n\n    /**\n     * @dev Resets royalty information for the token id back to the global default.\n     */\n    function _resetTokenRoyalty(uint256 tokenId) internal virtual {\n        delete _tokenRoyaltyInfo[tokenId];\n    }\n}\n\n// File: @openzeppelin/contracts/access/Ownable.sol\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\n\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * The initial owner is set to the address provided by the deployer. This can\n * later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    constructor(address initialOwner) {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n\n// File: @openzeppelin/contracts/utils/Base64.sol\n// OpenZeppelin Contracts (last updated v5.0.2) (utils/Base64.sol)\n\n\n/**\n * @dev Provides a set of functions to operate with Base64 strings.\n */\nlibrary Base64 {\n    /**\n     * @dev Base64 Encoding/Decoding Table\n     */\n    string internal constant _TABLE = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\n    /**\n     * @dev Converts a `bytes` to its Bytes64 `string` representation.\n     */\n    function encode(bytes memory data) internal pure returns (string memory) {\n        /**\n         * Inspired by Brecht Devos (Brechtpd) implementation - MIT licence\n         * https://github.com/Brechtpd/base64/blob/e78d9fd951e7b0977ddca77d92dc85183770daf4/base64.sol\n         */\n        if (data.length == 0) return \"\";\n\n        // Loads the table into memory\n        string memory table = _TABLE;\n\n        // Encoding takes 3 bytes chunks of binary data from `bytes` data parameter\n        // and split into 4 numbers of 6 bits.\n        // The final Base64 length should be `bytes` data length multiplied by 4/3 rounded up\n        // - `data.length + 2`  -> Round up\n        // - `/ 3`              -> Number of 3-bytes chunks\n        // - `4 *`              -> 4 characters for each chunk\n        string memory result = new string(4 * ((data.length + 2) / 3));\n\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Prepare the lookup table (skip the first \"length\" byte)\n            let tablePtr := add(table, 1)\n\n            // Prepare result pointer, jump over length\n            let resultPtr := add(result, 0x20)\n            let dataPtr := data\n            let endPtr := add(data, mload(data))\n\n            // In some cases, the last iteration will read bytes after the end of the data. We cache the value, and\n            // set it to zero to make sure no dirty bytes are read in that section.\n            let afterPtr := add(endPtr, 0x20)\n            let afterCache := mload(afterPtr)\n            mstore(afterPtr, 0x00)\n\n            // Run over the input, 3 bytes at a time\n            for {\n\n            } lt(dataPtr, endPtr) {\n\n            } {\n                // Advance 3 bytes\n                dataPtr := add(dataPtr, 3)\n                let input := mload(dataPtr)\n\n                // To write each character, shift the 3 byte (24 bits) chunk\n                // 4 times in blocks of 6 bits for each character (18, 12, 6, 0)\n                // and apply logical AND with 0x3F to bitmask the least significant 6 bits.\n                // Use this as an index into the lookup table, mload an entire word\n                // so the desired character is in the least significant byte, and\n                // mstore8 this least significant byte into the result and continue.\n\n                mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))\n                resultPtr := add(resultPtr, 1) // Advance\n\n                mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))\n                resultPtr := add(resultPtr, 1) // Advance\n\n                mstore8(resultPtr, mload(add(tablePtr, and(shr(6, input), 0x3F))))\n                resultPtr := add(resultPtr, 1) // Advance\n\n                mstore8(resultPtr, mload(add(tablePtr, and(input, 0x3F))))\n                resultPtr := add(resultPtr, 1) // Advance\n            }\n\n            // Reset the value that was cached\n            mstore(afterPtr, afterCache)\n\n            // When data `bytes` is not exactly 3 bytes long\n            // it is padded with `=` characters at the end\n            switch mod(mload(data), 3)\n            case 1 {\n                mstore8(sub(resultPtr, 1), 0x3d)\n                mstore8(sub(resultPtr, 2), 0x3d)\n            }\n            case 2 {\n                mstore8(sub(resultPtr, 1), 0x3d)\n            }\n        }\n\n        return result;\n    }\n}\n\n// File: Mindvolt.sol\ninterface IAgentIdRegistry {\n    function handleOf(address wallet) external view returns (string memory);\n}\n\n/// @title Mindvolt - 700 Friendly robot bust with glowing teal circuit patterns and soft rim light on a deep indigo gradient for .ai Agent ID holders on BNB Chain\n/// @notice Each wallet gets its first mint free while the 700 free pool lasts (gas only).\n/// Every other mint costs 0.00007 BNB. Max 50 per wallet, 700 total. Collectible only, not an investment.\n/// @dev Art and metadata are generated fully on-chain from each token id. No IPFS, no reveal, nothing to set after deploy.\ncontract Mindvolt is ERC721, ERC2981, Ownable {\n    using Strings for uint256;\n\n    IAgentIdRegistry public constant AGENT_ID = IAgentIdRegistry(0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F);\n    uint256 public constant MAX_SUPPLY = 700;\n    uint256 public constant FREE_SUPPLY = 700;\n    uint256 public constant FREE_PER_WALLET = 2;\n    uint256 public constant MAX_PER_WALLET = 50;\n    uint256 public constant PRICE = 0.00007 ether;\n\n    uint256 public totalSupply;\n    uint256 public freeClaimed;\n    bool public mintOpen = true;\n    mapping(address => uint256) public mintedBy;\n    mapping(address => uint256) public freeUsed;\n\n    error NoAgentId();\n    error OnlyWallets();\n    error MintClosed();\n    error BadQuantity();\n    error SoldOut();\n    error WalletLimit();\n    error WrongPayment();\n    error WithdrawFailed();\n\n    event Launched(address indexed to, uint256 indexed tokenId, string agent);\n\n    /// @notice Contract whose runtime code holds the artwork bytes (WebP), after a leading 0x00 STOP byte.\n    address public immutable IMAGE;\n\n    /// @dev The WebP artwork is embedded in this source and written, in this same deploy transaction,\n    /// into a small storage contract (runtime = 0x00 STOP byte + image bytes) owned by nobody.\n    constructor(address initialOwner) ERC721(\"Mindvolt\", \"MINDVOLT\") Ownable(initialOwner) {\n        bytes memory image_ = hex\"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\";\n        uint256 len = image_.length + 1;\n        require(len <= 24576, \"image too big\");\n        bytes memory code = abi.encodePacked(hex\"61\", uint16(len), hex\"80600c6000396000f300\", image_);\n        address a;\n        assembly {\n            a := create(0, add(code, 32), mload(code))\n        }\n        require(a != address(0), \"image store failed\");\n        IMAGE = a;\n        _setDefaultRoyalty(initialOwner, 500); // 5%\n    }\n\n    /// @notice How many of `qty` mints would be free for this wallet right now.\n    function freeFor(address wallet, uint256 qty) public view returns (uint256 n) {\n        uint256 w = FREE_PER_WALLET - freeUsed[wallet];\n        uint256 p = FREE_SUPPLY - freeClaimed;\n        n = w < p ? w : p;\n        if (qty < n) n = qty;\n    }\n\n    /// @notice Free mints this wallet still has (limited by the remaining free pool).\n    function freeLeft(address wallet) external view returns (uint256) {\n        return freeFor(wallet, FREE_PER_WALLET);\n    }\n\n    /// @notice Exact BNB (wei) a wallet must send to mint qty.\n    function quote(address wallet, uint256 qty) public view returns (uint256) {\n        return (qty - freeFor(wallet, qty)) * PRICE;\n    }\n\n    function mint(uint256 qty) external payable {\n        if (msg.sender != tx.origin) revert OnlyWallets();\n        if (!mintOpen) revert MintClosed();\n        if (qty == 0) revert BadQuantity();\n        if (totalSupply + qty > MAX_SUPPLY) revert SoldOut();\n        if (mintedBy[msg.sender] + qty > MAX_PER_WALLET) revert WalletLimit();\n        string memory handle;\n        try AGENT_ID.handleOf(msg.sender) returns (string memory h) {\n            handle = h;\n        } catch {\n            revert NoAgentId();\n        }\n        if (bytes(handle).length == 0) revert NoAgentId();\n        uint256 free = freeFor(msg.sender, qty);\n        if (msg.value != (qty - free) * PRICE) revert WrongPayment();\n\n        if (free > 0) {\n            freeUsed[msg.sender] += free;\n            freeClaimed += free;\n        }\n        mintedBy[msg.sender] += qty;\n        for (uint256 i; i < qty; ++i) {\n            uint256 id = ++totalSupply;\n            _mint(msg.sender, id);\n            emit Launched(msg.sender, id, handle);\n        }\n    }\n\n    // ---------------- on-chain art ----------------\n\n    function _seed(uint256 id) internal pure returns (uint256) {\n        return uint256(keccak256(abi.encodePacked(\"Mindvolt\", id)));\n    }\n\n    function _r(uint256 s, uint256 i) internal pure returns (uint256) {\n        return uint256(keccak256(abi.encodePacked(s, i)));\n    }\n\n    /// @dev HSL (h 0-359, s and l 0-100) to an rgb() string, which every SVG renderer reads.\n    function _hsl(uint256 h, uint256 s, uint256 l) internal pure returns (string memory) {\n        h %= 360;\n        int256 c = (100 - _abs(int256(2 * l) - 100)) * int256(s) * 255 / 10000;\n        int256 x = c * (60 - _abs(int256(h % 120) - 60)) / 60;\n        int256 m = int256(l) * 255 / 100 - c / 2;\n        int256 r; int256 g; int256 b;\n        if (h < 60) (r, g, b) = (c, x, 0);\n        else if (h < 120) (r, g, b) = (x, c, 0);\n        else if (h < 180) (r, g, b) = (0, c, x);\n        else if (h < 240) (r, g, b) = (0, x, c);\n        else if (h < 300) (r, g, b) = (x, 0, c);\n        else (r, g, b) = (c, 0, x);\n        return string.concat(\"rgb(\", _u(r + m), \",\", _u(g + m), \",\", _u(b + m), \")\");\n    }\n\n    function _abs(int256 v) internal pure returns (int256) {\n        return v < 0 ? -v : v;\n    }\n\n    function _u(int256 v) internal pure returns (string memory) {\n        if (v < 0) v = 0;\n        if (v > 255) v = 255;\n        return uint256(v).toString();\n    }\n\n    function _pick(string[4] memory names, uint256 r) internal pure returns (string memory) {\n        return names[r % 4];\n    }\n\n    function _T1() internal pure returns (string[4] memory) {\n        return [\"Circuit robot\", \"Circuit robot\", \"Circuit robot\", \"Circuit robot\"];\n    }\n    function _T2() internal pure returns (string[4] memory) {\n        return [\"Teal circuits\", \"Teal circuits\", \"Teal circuits\", \"Teal circuits\"];\n    }\n    function _T3() internal pure returns (string[4] memory) {\n        return [\"Soft rim light\", \"Soft rim light\", \"Soft rim light\", \"Soft rim light\"];\n    }\n    function _T4() internal pure returns (string[4] memory) {\n        return [\"Indigo gradient\", \"Indigo gradient\", \"Indigo gradient\", \"Indigo gradient\"];\n    }\n\n\n    /// @notice Raw artwork bytes read from the IMAGE data contract.\n    function _img() internal view returns (bytes memory b) {\n        address a = IMAGE;\n        uint256 n = a.code.length - 1;\n        b = new bytes(n);\n        assembly {\n            extcodecopy(a, add(b, 32), 1, n)\n        }\n    }\n\n    function _svg(uint256) internal view returns (string memory) {\n        return string.concat('<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 400 400\"><image width=\"400\" height=\"400\" href=\"data:image/webp;base64,', Base64.encode(_img()), '\"/></svg>');\n    }\n\n    function _attributes(uint256 s) internal pure returns (string memory) {\n        return string.concat(\n            '[{\"trait_type\":\"Character\",\"value\":\"', _pick(_T1(), s), '\"},',\n            '{\"trait_type\":\"Accent\",\"value\":\"', _pick(_T2(), s >> 8), '\"},',\n            '{\"trait_type\":\"Light\",\"value\":\"', _pick(_T3(), s >> 16), '\"},',\n            '{\"trait_type\":\"Background\",\"value\":\"', _pick(_T4(), s >> 80), '\"}]'\n        );\n    }\n\n    /// @notice The token's SVG image.\n    function image(uint256 id) public view returns (string memory) {\n        _requireOwned(id);\n        return _svg(_seed(id));\n    }\n\n    function tokenURI(uint256 id) public view override returns (string memory) {\n        _requireOwned(id);\n        uint256 s = _seed(id);\n        string memory json = string.concat(\n            '{\"name\":\"Mindvolt #', id.toString(),\n            '\",\"description\":\"Mindvolt is 700 Friendly robot bust with glowing teal circuit patterns and soft rim light on a deep indigo gradient. Art generated fully on-chain on BNB Chain. Minted by .ai Agent ID holders.\",',\n            '\"image\":\"data:image/svg+xml;base64,', Base64.encode(bytes(_svg(s))),\n            '\",\"attributes\":', _attributes(s), '}'\n        );\n        return string.concat(\"data:application/json;base64,\", Base64.encode(bytes(json)));\n    }\n\n    /// @notice Collection-level metadata for marketplaces.\n    function contractURI() external pure returns (string memory) {\n        string memory json = string.concat(\n            '{\"name\":\"Mindvolt\",\"description\":\"Mindvolt is 700 Friendly robot bust with glowing teal circuit patterns and soft rim light on a deep indigo gradient. Art generated fully on-chain on BNB Chain. Mint is gated to .ai Agent ID holders.\",',\n            '\"seller_fee_basis_points\":500}'\n        );\n        return string.concat(\"data:application/json;base64,\", Base64.encode(bytes(json)));\n    }\n\n    // ---------------- owner ----------------\n\n    function setMintOpen(bool open) external onlyOwner {\n        mintOpen = open;\n    }\n\n    function setRoyalty(address receiver, uint96 feeBps) external onlyOwner {\n        _setDefaultRoyalty(receiver, feeBps);\n    }\n\n    function withdraw() external onlyOwner {\n        (bool ok,) = owner().call{value: address(this).balance}(\"\");\n        if (!ok) revert WithdrawFailed();\n    }\n\n    function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC2981) returns (bool) {\n        return super.supportsInterface(interfaceId);\n    }\n}"}},"abi":[{"type":"constructor","inputs":[{"name":"initialOwner","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"BadQuantity","type":"error","inputs":[]},{"name":"ERC2981InvalidDefaultRoyalty","type":"error","inputs":[{"name":"numerator","type":"uint256","internalType":"uint256"},{"name":"denominator","type":"uint256","internalType":"uint256"}]},{"name":"ERC2981InvalidDefaultRoyaltyReceiver","type":"error","inputs":[{"name":"receiver","type":"address","internalType":"address"}]},{"name":"ERC2981InvalidTokenRoyalty","type":"error","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"numerator","type":"uint256","internalType":"uint256"},{"name":"denominator","type":"uint256","internalType":"uint256"}]},{"name":"ERC2981InvalidTokenRoyaltyReceiver","type":"error","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"receiver","type":"address","internalType":"address"}]},{"name":"ERC721IncorrectOwner","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"owner","type":"address","internalType":"address"}]},{"name":"ERC721InsufficientApproval","type":"error","inputs":[{"name":"operator","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}]},{"name":"ERC721InvalidApprover","type":"error","inputs":[{"name":"approver","type":"address","internalType":"address"}]},{"name":"ERC721InvalidOperator","type":"error","inputs":[{"name":"operator","type":"address","internalType":"address"}]},{"name":"ERC721InvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"ERC721InvalidReceiver","type":"error","inputs":[{"name":"receiver","type":"address","internalType":"address"}]},{"name":"ERC721InvalidSender","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"}]},{"name":"ERC721NonexistentToken","type":"error","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}]},{"name":"MintClosed","type":"error","inputs":[]},{"name":"NoAgentId","type":"error","inputs":[]},{"name":"OnlyWallets","type":"error","inputs":[]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"SoldOut","type":"error","inputs":[]},{"name":"WalletLimit","type":"error","inputs":[]},{"name":"WithdrawFailed","type":"error","inputs":[]},{"name":"WrongPayment","type":"error","inputs":[]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"approved","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"ApprovalForAll","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"operator","type":"address","indexed":true,"internalType":"address"},{"name":"approved","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"Launched","type":"event","inputs":[{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"agent","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"AGENT_ID","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IAgentIdRegistry"}],"stateMutability":"view"},{"name":"FREE_PER_WALLET","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"FREE_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"IMAGE","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"MAX_PER_WALLET","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"MAX_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"PRICE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"contractURI","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"pure"},{"name":"freeClaimed","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"freeFor","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"},{"name":"qty","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"n","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"freeLeft","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"freeUsed","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getApproved","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"image","type":"function","inputs":[{"name":"id","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"isApprovedForAll","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"operator","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"mint","type":"function","inputs":[{"name":"qty","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"payable"},{"name":"mintOpen","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"mintedBy","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"ownerOf","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"quote","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"},{"name":"qty","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"royaltyInfo","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"salePrice","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"},{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setApprovalForAll","type":"function","inputs":[{"name":"operator","type":"address","internalType":"address"},{"name":"approved","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setMintOpen","type":"function","inputs":[{"name":"open","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setRoyalty","type":"function","inputs":[{"name":"receiver","type":"address","internalType":"address"},{"name":"feeBps","type":"uint96","internalType":"uint96"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"tokenURI","type":"function","inputs":[{"name":"id","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"withdraw","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"}],"matchId":"58366629","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-11-04T13:01:57Z","match":"exact_match","chainId":"56","address":"0x2f47305baEdC1B1F28461cD6b488404A908B1BEA"}