{"sources":{"Mechfarm.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: Mechfarm.sol\ninterface IAgentIdRegistry {\n    function handleOf(address wallet) external view returns (string memory);\n}\n\n/// @title Mechfarm - 4000 Chrome robot farmer bunny with cyan circuit ears and tiny straw hat on a blue-green gradient for .ai Agent ID holders on BNB Chain\n/// @notice Each wallet gets its first mint free while the 4000 free pool lasts (gas only).\n/// Every other mint costs 0.00007 BNB. Max 50 per wallet, 4000 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 Mechfarm is ERC721, ERC2981, Ownable {\n    using Strings for uint256;\n\n    IAgentIdRegistry public constant AGENT_ID = IAgentIdRegistry(0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F);\n    uint256 public constant MAX_SUPPLY = 4000;\n    uint256 public constant FREE_SUPPLY = 4000;\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(\"Mechfarm\", \"MECHFARM\") 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(\"Mechfarm\", 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 farmer bunny\", \"Robot farmer bunny\", \"Robot farmer bunny\", \"Robot farmer bunny\"];\n    }\n    function _T2() internal pure returns (string[4] memory) {\n        return [\"Straw hat\", \"Straw hat\", \"Straw hat\", \"Straw hat\"];\n    }\n    function _T3() internal pure returns (string[4] memory) {\n        return [\"Cyan rim light\", \"Cyan rim light\", \"Cyan rim light\", \"Cyan rim light\"];\n    }\n    function _T4() internal pure returns (string[4] memory) {\n        return [\"Blue-green gradient\", \"Blue-green gradient\", \"Blue-green gradient\", \"Blue-green 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\":\"Mechfarm #', id.toString(),\n            '\",\"description\":\"Mechfarm is 4000 Chrome robot farmer bunny with cyan circuit ears and tiny straw hat on a blue-green 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\":\"Mechfarm\",\"description\":\"Mechfarm is 4000 Chrome robot farmer bunny with cyan circuit ears and tiny straw hat on a blue-green 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":"58201227","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-11-03T10:10:54Z","match":"exact_match","chainId":"56","address":"0x1FAb92b937572C79550aEEe51Cee77d3aDD20367"}