{"sources":{"Chimerito.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: Chimerito.sol\ninterface IAgentIdRegistry {\n    function handleOf(address wallet) external view returns (string memory);\n}\n\n/// @title Chimerito - 2255 Baby chimera with lion face goat horns and snake tail in golden Greek ruins at sunset for .ai Agent ID holders on BNB Chain\n/// @notice Each wallet gets its first mint free while the 332 free pool lasts (gas only).\n/// Every other mint costs 0.00005 BNB. Max 50 per wallet, 2255 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 Chimerito is ERC721, ERC2981, Ownable {\n    using Strings for uint256;\n\n    IAgentIdRegistry public constant AGENT_ID = IAgentIdRegistry(0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F);\n    uint256 public constant MAX_SUPPLY = 2255;\n    uint256 public constant FREE_SUPPLY = 332;\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(\"Chimerito\", \"CHIMERITO\") 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(\"Chimerito\", 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 [\"Baby chimera\", \"Baby chimera\", \"Baby chimera\", \"Baby chimera\"];\n    }\n    function _T2() internal pure returns (string[4] memory) {\n        return [\"Gold collar\", \"Gold collar\", \"Gold collar\", \"Gold collar\"];\n    }\n    function _T3() internal pure returns (string[4] memory) {\n        return [\"Sunset rim light\", \"Sunset rim light\", \"Sunset rim light\", \"Sunset rim light\"];\n    }\n    function _T4() internal pure returns (string[4] memory) {\n        return [\"Greek ruins\", \"Greek ruins\", \"Greek ruins\", \"Greek ruins\"];\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\":\"Chimerito #', id.toString(),\n            '\",\"description\":\"Chimerito is 2255 Baby chimera with lion face goat horns and snake tail in golden Greek ruins at sunset. 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\":\"Chimerito\",\"description\":\"Chimerito is 2255 Baby chimera with lion face goat horns and snake tail in golden Greek ruins at sunset. 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":"58043530","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-11-02T05:56:27Z","match":"exact_match","chainId":"56","address":"0x3203D93cE535c2ec88c99d1967324Fe556A4e8f6"}