{"sources":{"Hivejupiter.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: Hivejupiter.sol\ninterface IAgentIdRegistry {\n    function handleOf(address wallet) external view returns (string memory);\n}\n\n/// @title Hivejupiter - 500 Cute Jupiter-headed creature with swirling cream-orange stripes, honeycomb collar and tiny golden bees orbiting like moons in violet starry space for .ai Agent ID holders on BNB Chain\n/// @notice Each wallet gets its first mint free while the 500 free pool lasts (gas only).\n/// Every other mint costs 0.00007 BNB. Max 50 per wallet, 500 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 Hivejupiter is ERC721, ERC2981, Ownable {\n    using Strings for uint256;\n\n    IAgentIdRegistry public constant AGENT_ID = IAgentIdRegistry(0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F);\n    uint256 public constant MAX_SUPPLY = 500;\n    uint256 public constant FREE_SUPPLY = 500;\n    uint256 public constant FREE_PER_WALLET = 2;\n    uint256 public constant MAX_PER_WALLET = 50;\n    uint256 public constant PRICE = 0.00007 ether;\n\n    uint256 public totalSupply;\n    uint256 public freeClaimed;\n    bool public mintOpen = true;\n    mapping(address => uint256) public mintedBy;\n    mapping(address => uint256) public freeUsed;\n\n    error NoAgentId();\n    error OnlyWallets();\n    error MintClosed();\n    error BadQuantity();\n    error SoldOut();\n    error WalletLimit();\n    error WrongPayment();\n    error WithdrawFailed();\n\n    event Launched(address indexed to, uint256 indexed tokenId, string agent);\n\n    /// @notice Contract whose runtime code holds the artwork bytes (WebP), after a leading 0x00 STOP byte.\n    address public immutable IMAGE;\n\n    /// @dev The WebP artwork is embedded in this source and written, in this same deploy transaction,\n    /// into a small storage contract (runtime = 0x00 STOP byte + image bytes) owned by nobody.\n    constructor(address initialOwner) ERC721(\"Hivejupiter\", \"HIVEJUPITER\") 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(\"Hivejupiter\", 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 [\"Jupiter creature\", \"Jupiter creature\", \"Jupiter creature\", \"Jupiter creature\"];\n    }\n    function _T2() internal pure returns (string[4] memory) {\n        return [\"Honeycomb collar\", \"Honeycomb collar\", \"Honeycomb collar\", \"Honeycomb collar\"];\n    }\n    function _T3() internal pure returns (string[4] memory) {\n        return [\"Warm rim light\", \"Warm rim light\", \"Warm rim light\", \"Warm rim light\"];\n    }\n    function _T4() internal pure returns (string[4] memory) {\n        return [\"Violet starry space\", \"Violet starry space\", \"Violet starry space\", \"Violet starry space\"];\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\":\"Hivejupiter #', id.toString(),\n            '\",\"description\":\"Hivejupiter is 500 Cute Jupiter-headed creature with swirling cream-orange stripes, honeycomb collar and tiny golden bees orbiting like moons in violet starry space. 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\":\"Hivejupiter\",\"description\":\"Hivejupiter is 500 Cute Jupiter-headed creature with swirling cream-orange stripes, honeycomb collar and tiny golden bees orbiting like moons in violet starry space. 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":"58357132","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-11-04T11:19:03Z","match":"exact_match","chainId":"56","address":"0x8DF74cBe998F8d447E7c77dD5117aFB940605400"}