{"sources":{"Servopaw.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: Servopaw.sol\ninterface IAgentIdRegistry {\n    function handleOf(address wallet) external view returns (string memory);\n}\n\n/// @title Servopaw - 2211 Friendly teal robot cat mechanic with amber eyes in a bright futuristic workshop for .ai Agent ID holders on BNB Chain\n/// @notice Each wallet gets its first mint free while the 316 free pool lasts (gas only).\n/// Every other mint costs 0.00005 BNB. Max 50 per wallet, 2211 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 Servopaw is ERC721, ERC2981, Ownable {\n    using Strings for uint256;\n\n    IAgentIdRegistry public constant AGENT_ID = IAgentIdRegistry(0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F);\n    uint256 public constant MAX_SUPPLY = 2211;\n    uint256 public constant FREE_SUPPLY = 316;\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(\"Servopaw\", \"SERVOPAW\") 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(\"Servopaw\", id)));\n    }\n\n    function _r(uint256 s, uint256 i) internal pure returns (uint256) {\n        return uint256(keccak256(abi.encodePacked(s, i)));\n    }\n\n    /// @dev HSL (h 0-359, s and l 0-100) to an rgb() string, which every SVG renderer reads.\n    function _hsl(uint256 h, uint256 s, uint256 l) internal pure returns (string memory) {\n        h %= 360;\n        int256 c = (100 - _abs(int256(2 * l) - 100)) * int256(s) * 255 / 10000;\n        int256 x = c * (60 - _abs(int256(h % 120) - 60)) / 60;\n        int256 m = int256(l) * 255 / 100 - c / 2;\n        int256 r; int256 g; int256 b;\n        if (h < 60) (r, g, b) = (c, x, 0);\n        else if (h < 120) (r, g, b) = (x, c, 0);\n        else if (h < 180) (r, g, b) = (0, c, x);\n        else if (h < 240) (r, g, b) = (0, x, c);\n        else if (h < 300) (r, g, b) = (x, 0, c);\n        else (r, g, b) = (c, 0, x);\n        return string.concat(\"rgb(\", _u(r + m), \",\", _u(g + m), \",\", _u(b + m), \")\");\n    }\n\n    function _abs(int256 v) internal pure returns (int256) {\n        return v < 0 ? -v : v;\n    }\n\n    function _u(int256 v) internal pure returns (string memory) {\n        if (v < 0) v = 0;\n        if (v > 255) v = 255;\n        return uint256(v).toString();\n    }\n\n    function _pick(string[4] memory names, uint256 r) internal pure returns (string memory) {\n        return names[r % 4];\n    }\n\n    function _T1() internal pure returns (string[4] memory) {\n        return [\"Robot cat mechanic\", \"Robot cat mechanic\", \"Robot cat mechanic\", \"Robot cat mechanic\"];\n    }\n    function _T2() internal pure returns (string[4] memory) {\n        return [\"Tool harness\", \"Tool harness\", \"Tool harness\", \"Tool harness\"];\n    }\n    function _T3() internal pure returns (string[4] memory) {\n        return [\"Warm rim light\", \"Warm rim light\", \"Warm rim light\", \"Warm rim light\"];\n    }\n    function _T4() internal pure returns (string[4] memory) {\n        return [\"Future workshop\", \"Future workshop\", \"Future workshop\", \"Future workshop\"];\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\":\"Servopaw #', id.toString(),\n            '\",\"description\":\"Servopaw is 2211 Friendly teal robot cat mechanic with amber eyes in a bright futuristic workshop. 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\":\"Servopaw\",\"description\":\"Servopaw is 2211 Friendly teal robot cat mechanic with amber eyes in a bright futuristic workshop. 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":"58043511","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-11-02T05:56:15Z","match":"exact_match","chainId":"56","address":"0xAB23259Cac7D87d8cfE0ADaba80827d3e3AcC99F"}