{"sources":{"Glitchdroid.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: Glitchdroid.sol\ninterface IAgentIdRegistry {\n    function handleOf(address wallet) external view returns (string memory);\n}\n\n/// @title Glitchdroid - 600 Friendly cyberpunk chrome droid with a pixel-glitch magenta-cyan visor and tiny antennae on a dark teal-magenta gradient for .ai Agent ID holders on BNB Chain\n/// @notice Each wallet gets its first mint free while the 600 free pool lasts (gas only).\n/// Every other mint costs 0.00007 BNB. Max 50 per wallet, 600 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 Glitchdroid is ERC721, ERC2981, Ownable {\n    using Strings for uint256;\n\n    IAgentIdRegistry public constant AGENT_ID = IAgentIdRegistry(0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F);\n    uint256 public constant MAX_SUPPLY = 600;\n    uint256 public constant FREE_SUPPLY = 600;\n    uint256 public constant FREE_PER_WALLET = 2;\n    uint256 public constant MAX_PER_WALLET = 50;\n    uint256 public constant PRICE = 0.00007 ether;\n\n    uint256 public totalSupply;\n    uint256 public freeClaimed;\n    bool public mintOpen = true;\n    mapping(address => uint256) public mintedBy;\n    mapping(address => uint256) public freeUsed;\n\n    error NoAgentId();\n    error OnlyWallets();\n    error MintClosed();\n    error BadQuantity();\n    error SoldOut();\n    error WalletLimit();\n    error WrongPayment();\n    error WithdrawFailed();\n\n    event Launched(address indexed to, uint256 indexed tokenId, string agent);\n\n    /// @notice Contract whose runtime code holds the artwork bytes (WebP), after a leading 0x00 STOP byte.\n    address public immutable IMAGE;\n\n    /// @dev The WebP artwork is embedded in this source and written, in this same deploy transaction,\n    /// into a small storage contract (runtime = 0x00 STOP byte + image bytes) owned by nobody.\n    constructor(address initialOwner) ERC721(\"Glitchdroid\", \"GLITCHDROID\") 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(\"Glitchdroid\", 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 [\"Glitch droid\", \"Glitch droid\", \"Glitch droid\", \"Glitch droid\"];\n    }\n    function _T2() internal pure returns (string[4] memory) {\n        return [\"Pixel-glitch visor\", \"Pixel-glitch visor\", \"Pixel-glitch visor\", \"Pixel-glitch visor\"];\n    }\n    function _T3() internal pure returns (string[4] memory) {\n        return [\"Magenta-cyan rim light\", \"Magenta-cyan rim light\", \"Magenta-cyan rim light\", \"Magenta-cyan rim light\"];\n    }\n    function _T4() internal pure returns (string[4] memory) {\n        return [\"Teal-magenta gradient\", \"Teal-magenta gradient\", \"Teal-magenta gradient\", \"Teal-magenta gradient\"];\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\":\"Glitchdroid #', id.toString(),\n            '\",\"description\":\"Glitchdroid is 600 Friendly cyberpunk chrome droid with a pixel-glitch magenta-cyan visor and tiny antennae on a dark teal-magenta gradient. 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\":\"Glitchdroid\",\"description\":\"Glitchdroid is 600 Friendly cyberpunk chrome droid with a pixel-glitch magenta-cyan visor and tiny antennae on a dark teal-magenta gradient. 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":"58263590","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-11-03T20:55:26Z","match":"exact_match","chainId":"56","address":"0xe3F0085fd94D4Fb2AE9ACb4B49f6c0504E3546A0"}