{"sources":{"Nanobee.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: Nanobee.sol\ninterface IAgentIdRegistry {\n    function handleOf(address wallet) external view returns (string memory);\n}\n\n/// @title Nanobee - 6666 Friendly yellow robot bee with green eyes and holo wings in a bright futuristic lab for .ai Agent ID holders on BNB Chain\n/// @notice Each wallet gets its first mint free while the 330 free pool lasts (gas only).\n/// Every other mint costs 0.00005 BNB. Max 50 per wallet, 6666 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 Nanobee is ERC721, ERC2981, Ownable {\n    using Strings for uint256;\n\n    IAgentIdRegistry public constant AGENT_ID = IAgentIdRegistry(0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F);\n    uint256 public constant MAX_SUPPLY = 6666;\n    uint256 public constant FREE_SUPPLY = 330;\n    uint256 public constant FREE_PER_WALLET = 1;\n    uint256 public constant MAX_PER_WALLET = 50;\n    uint256 public constant PRICE = 0.00005 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(\"Nanobee\", \"NANOBEE\") 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(\"Nanobee\", 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 [\"Robot bee\", \"Robot bee\", \"Robot bee\", \"Robot bee\"];\n    }\n    function _T2() internal pure returns (string[4] memory) {\n        return [\"Tool harness\", \"Tool harness\", \"Tool harness\", \"Tool harness\"];\n    }\n    function _T3() internal pure returns (string[4] memory) {\n        return [\"Teal orange rim light\", \"Teal orange rim light\", \"Teal orange rim light\", \"Teal orange rim light\"];\n    }\n    function _T4() internal pure returns (string[4] memory) {\n        return [\"Future lab\", \"Future lab\", \"Future lab\", \"Future lab\"];\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\":\"Outfit\",\"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\":\"Nanobee #', id.toString(),\n            '\",\"description\":\"Nanobee is 6666 Friendly yellow robot bee with green eyes and holo wings in a bright futuristic lab. 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\":\"Nanobee\",\"description\":\"Nanobee is 6666 Friendly yellow robot bee with green eyes and holo wings in a bright futuristic lab. 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":"58051581","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-11-02T07:55:17Z","match":"exact_match","chainId":"56","address":"0x4cd813aD6C3C2cc740d48F357D7E0f0e053449f1"}