{"sources":{"Mercubo.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: Mercubo.sol\ninterface IAgentIdRegistry {\n    function handleOf(address wallet) external view returns (string memory);\n}\n\n/// @title Mercubo - 3333 Cheerful Mercury sprite kid with silver cratered skin and astronaut collar before a blazing sun for .ai Agent ID holders on BNB Chain\n/// @notice Each wallet gets its first mint free while the 303 free pool lasts (gas only).\n/// Every other mint costs 0.00005 BNB. Max 50 per wallet, 3333 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 Mercubo is ERC721, ERC2981, Ownable {\n    using Strings for uint256;\n\n    IAgentIdRegistry public constant AGENT_ID = IAgentIdRegistry(0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F);\n    uint256 public constant MAX_SUPPLY = 3333;\n    uint256 public constant FREE_SUPPLY = 303;\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(\"Mercubo\", \"MERCUBO\") 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(\"Mercubo\", 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 [\"Mercury sprite kid\", \"Mercury sprite kid\", \"Mercury sprite kid\", \"Mercury sprite kid\"];\n    }\n    function _T2() internal pure returns (string[4] memory) {\n        return [\"Astronaut collar\", \"Astronaut collar\", \"Astronaut collar\", \"Astronaut collar\"];\n    }\n    function _T3() internal pure returns (string[4] memory) {\n        return [\"Golden rim light\", \"Golden rim light\", \"Golden rim light\", \"Golden rim light\"];\n    }\n    function _T4() internal pure returns (string[4] memory) {\n        return [\"Blazing sun and stars\", \"Blazing sun and stars\", \"Blazing sun and stars\", \"Blazing sun and stars\"];\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\":\"Mercubo #', id.toString(),\n            '\",\"description\":\"Mercubo is 3333 Cheerful Mercury sprite kid with silver cratered skin and astronaut collar before a blazing sun. 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\":\"Mercubo\",\"description\":\"Mercubo is 3333 Cheerful Mercury sprite kid with silver cratered skin and astronaut collar before a blazing sun. 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":"58043520","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-11-02T05:56:21Z","match":"exact_match","chainId":"56","address":"0xa1bC72EcEC9f1F73Be9ED0c21b5cB880f42dA1A3"}