{"sources":{"Neidroidjuan.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: Neidroidjuan.sol\ninterface IAgentIdRegistry {\n    function handleOf(address wallet) external view returns (string memory);\n}\n\n/// @title Neidroidjuan - 999 Tired but determined chrome droid with a spiral neijuan mark holding a tiny coffee cup on an orange gradient for .ai Agent ID holders on BNB Chain\n/// @notice Each wallet gets its first mint free while the 999 free pool lasts (gas only).\n/// Every other mint costs 0.00007 BNB. Max 50 per wallet, 999 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 Neidroidjuan is ERC721, ERC2981, Ownable {\n    using Strings for uint256;\n\n    IAgentIdRegistry public constant AGENT_ID = IAgentIdRegistry(0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F);\n    uint256 public constant MAX_SUPPLY = 999;\n    uint256 public constant FREE_SUPPLY = 999;\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(\"Neidroidjuan\", \"NEIDROIDJUAN\") Ownable(initialOwner) {\n        bytes memory image_ = hex\"5249464694380000574542505650382088380000d027019d012a900190013ec156a44d27a4a3ae27b36ce9c018094dd7a70931b571695d906ebc48b2ff22a2efdbb995f19fe3fcc0bdbbbe6fa75febfbcf39daf4f2e99b660edc770beef5f0be0c7597e13fd12d45e07fe8bc3e3f1de7313ddfa8d9d5fc1743fffcbe74e56b832b0d9b7e318970e411cd2c0eb2de95ac8452ceb1896807b069cde23f339ce9704aefaa4ab08b0d8ac4191e49d876c9684acb2566be6ac0cac34555ec8910c8747148491a27622d3fd4a41ed714d0e9796a6b2329efecdeb870eeed2428d84386a2476112e6c2673244e9c7fcd0f3946daa52984654cf74f24d7225816630c69c95bf497cbf99eb2ef6ca2fcdff0ccd6141213c8c364d83864bbb12a3227e513bfef4602672e323b37715d594e87b1ade4b5ca7351a0847bd18d85ef450f949e7589593267841954e0c27365da80b77fb1704bc45883ceafceba7371f6698e57777f2edfa0ace2a41b60b0a0b70eb470a0e25eceaf9f3960bf4b6518b3f825336c4720d56111c948a6a53567ad53fbf224b42a5ef6441af561f7e1a1006fb397f8c2a4c97fa14d625155d897b87a0613838f438571c1fa1fcf074b3c697fed10f3de5a57b0765dac18e6c88cc949a35749b3fee8143e6c0b8c060e7448139a793b381ec797baab8a3ed6831cc0b1be7ed3565fbd824da2f1182fc2bf772e4752515de5c672b572a8a983772ee86889741fb5b84ceeab43a9dda56677bab3a4b15876b078ee49195a39f00aee7ba3fda2012cf6e8495070552b37cdf3127158393f03154ab69dd0f1b39ab17d5febadb07de0d66255ae8e9064d1f6e0072b23d8b9513807f35f4a940a21a05cc779eed57459588f4c41c1e75b19884c8d76ac6f20eab8f888aea77b970a1f6f06de424d3c60744822c1c55cdb7cbd360795c7a3af4ccdb6fd5e9cfbba130024048e4ae7624df631200f9a0fb7276752df137eb5bc0981ef3ae15e99ea865babf30518a02ce6ddc85c018081828822311c8135c9f4c885f5d524af6dde2f3af860cfb2fc58e0bd7a964aa5e0d1bc5df127309a06b599fb35fc3ae4526782f6c3f26fbb5748740c8860296e58a380999b1568054af475cde36d0f32f18f9af99c143454c3b344e3f8aad6f98af0052464478b022774009711be181578c936057f858772c64d1a5a2e8d207fd016d930cf66c945837824fe3cabc3cacca1b09626e148e6ff9f5ac6b73902b47853dd4e5e10e5f019b6dbf38d614b1a7e3ed2c19b4110be8a95f9838c2ea1b307288f92180d562218e5a8678b80eca5c0e2a3346a58349db4179489c511fbe1042bd008b84d0980c9189eb79408605a4d69be14e920c4aa94c70519a7ccce4c0501f7e7382b5a6f38671d83382663f26a9e76213a6dd5dbc34ba4ceaf07d5ce446af3c5f5f6de42d66add804480a60f701a43f5eeac6b80bd49ffbda4fde387dbf85ab299fcfdcde5108d467f6930d6a94a7a4e5de2b48a63bc287275c0b9d4d08ac34f17ec4ce21743028ff63e6804973dc14e4473d0bea0cce742a3d0021a529b4cee20d460d16ea4805efbdadb17b13bc2542bedbd6414f407994b2d961090fffd1ff657167d32b694a786e8b0db55779129d987e6e8b99344eab2a221e25bc1ed8bfbf699536036efed31343251c06e6e4f7fb92719c19693e33743bc5cb4d24544f226c187de6a345ac660b4656430360e3cba7b3a555dbf1e93120947b2d0a21c79a9da352a45c2df680fcbcde9707a1c06e406452a40bc67c197befa2ea19b717a1bfeb12298378f8d827b33939120e42f39c235f8f9ce2c3fd9202725944056629be53ab73fde0310335d245216cc5bb572f1dd8081e44ef4003bc56fc74692961cebe68a70148bd57586a4a4e1aee2eb250096c0fbf366c745c04487c8abbd5236d86cbd4d9eff843d6f49c09b69cef1196e610c875f0aa13e4b30f3ff7522b9e2aceea39f53347baa7e97a90f4119b9e6701e85cc4cc9b11d6561ad1e36219ef0bd44ce6b0639422681ee5738565a30b9651bb5d7bd941928d6a1ecede842b4a91d46047bb9fa24cb032c1e132b855c3d30a6ef32935c1dc49e944efa481472f16933f4ba47ee3eecde8947fabf01d9c5c7383db492607b4487f5aefba951400600ec3467470cc92c0d9f6a5e4378dec967dadaae5cfce84f34bf42f23e52b1836c5c6523ec14208f226ede98ad0186cf754419d9c7e373422c2b6f20f543ed2b8afc6c1e6004e7fbb23d74af058246876e0f6ac3b9a2793f0b0a6474d0ae5d5871ab49129b7b48ffc296561923903fbdd1de4082c0650544bc410fad4514d44d8e356ab5b129cc011cf2fdb433247846f2cbdc1c74ac80be45acd1fdc214941e0a647e159bf4c505a2f8ccb9448d7a138d83ff397cb1400fe41af51436c507e1ab843d88c271be4462d7cef4a18ada1db4314e532d86808112048168615c4241bb1041393f29f2ce252de44ea1d7a2fa4a822bed483ece1a4cd2d632cf9eec5d2ac2196cf5740e2014cda7af9bc11bc8d25c1a71b56a4319258015a42000c797c0e743389c5d8dcbd3d2ea15d3d658fb5a976a3a037f177ad7caa4bff2f0922549237bcef2077504639d03229e1ecccfeeaf7bd87199c5a423d2c0b30f2e116e0048c602dbdeb18a4d3eb8219b240d945ffc57b872b675b676d4446fa2abfde0d44fc001db2aaab9c80fb2897fdab7f23fbbe349eb6d10f47bf77a2630a1f95026dd91ee171e86f73d021387e61f09ac6c701101549eadf0fd5131da55f8e18741d3c50b9157d0f9da7bdd098c0ec59a3a92f0004b0f510af14bfe6116d1899ed84b620dd071a4b853cc1c957255aef7114cc728809d7f8c2f5809da6bdaa96df792a8094cc33cc7649e158bad73d321a197a260276923cc61a8482a00940cb009a749aa76a9f6a4519633d366b2965d320535f919866eb9852ec51411136c2aa7c32b43a792f08fee5dd2b935d81775e5fc3363a4de5374c55ad576b0726f5336d65d745a8781a3b55afac96d6f7fc23b60089ede097ed6877b807ce8a72bc86a86d0dc5cf16b5994907e51e64fa65d072bff3e3f2c909a5f0a56ae0d4f90b2a1fdad8409671a30bb30c89bc6c987cc4186d7371afb7b59ac5219d34fcb91233b8e3d5ff302317439eca60fd2746a0bb2a1d7b9923a6a7287bf040bd035a0de52a9d6efc3ab2585c37a85c40654fd48dbcd6ff34dac70f4b1fed64ccb6506e25eda1942cff8a1674148ab636a67df01df3a64e7a4d73c8b08054bec7708cab5a8b2183d45e81b9bf2bb05a3550ef776be442551107eacd31a55de9e634f1b8282b2eaf2627bf1da43ff2c99d0798f4c6f38d41aa48c64321e7594c8339c000feea0e0ff25f13ee8263ffe055fd5d7ecd756ab1f6816f19567ea19f793c5c1373493a4ec1c753e2ef410a9ba0c9c32889314ec26792882cfa0b444b4459d8be5e5ee10179a49ec26aa985af0c88ce663847d36aea295e5056c617fd875a967ee71924da6c999524115196d274cfea8be0a1d7e99001ecfffffbe7071157ad8bfddc976451b1f768081d1d953899942732fd5a689105027426f598bc2873fe4dc4fc532e939ce0111d3aee8c6e28de9a70760cfc5919d7074135bf078e0c511f75b814721f6d628d9a27740a58850608ef2a20df545fbc1546442b52ea0bfa6aa14687aee8cbd2807b5819de0c564f97f3f34c0331d222b408a7c3c94f0668c4603cf6444b26502590be1c1f269b7484a6130a83c3b06a78d71363df135182bbf5cd49559d6da8670eab5307f64098eb26913074302513038c33faf086f0b77cb811eb90d6c0790463f2f945d668793cbff100000004a8732980aa63734ba4d30b9403551d01979671adeb29588ae8a001a8c83d0fdb0935fcdc07fe2b14cd678ce82c22467daede1fbe026a9cd6005c24ce28cddc5ba90b2b0b5e2f0843d9931b65ff36666bbc528aa832a0b75831d2828989e9d35bda6ba4b30ee06d8ae4a2aad177e0907e742e40d7afaafee9d2626ec946de1d1355afbdee0f129671f00d90114f2eeaf2a9d8050a07ebe45a7b03b88569d7c0c5b48022c0cd341abeeb3002cec56d5866844f884ecf2d79b89d1a83b8f36d13ad5e41a90004cda2b9e098ee7e7bbb4d1b57af875b51fe43fbaa426223440c4fc379c945788f5ec5c7b38ef65fea62f77f10fd0e12f26e75515ea414dd81d76251e0856e3a31efc9abcef0df9404d0bc5c8ef97b13ee4a2ebf24a82e39dba87edd026759467a13bbf410dc986fc7b1b2739de5444fc63aebcf1cbdd762cc43bf2422fd294721fa3286b3d7a1954a74013dfaa960ea794d6310ff6f4ec01be3c0db4f9c912132a400a7e69e0d4242c27b5b0daa4060090b1b64ad01e2b7c7cc3cfa5ffeda9838179f08ad0cc26a9ef59fd056c847f387b06800368e9b277b65b060288dacb6b28623be586434124e2a2a4cedc28772315e131d2ac5cba47387730290f0857a2725c7151e371091a9592b8c6f08ce4c925807b3a809c1918e47a704568e9f4e0a865c9fb4fc2b4be6bc2c7fd64b729a183ebf1e8a27a65b825f3c0d6f7db0502b8f4d7e544d49d0f8ca1281741b7735478227ab3ee0697ece53304c132c09c3ffdce39a0b6b6d20fbfa8d3e0aaaa33eb4b3109dade8ae08c7b5866ffe953c58354287985ff5a30523ebd9b5ebc2d1a59cd3dd4e5ee272582a4b6d020130d4ef26b1758741188abc3640dd867bef9296810c19f658e22672cb17cdcac2b680cf249f5a8fd167f2535630334d24fd50a9e9a11a53532816de73ef754ced1a66b3aaf74b6f27601ae6f847f79d903824ac8e8647c45598ebf40131cd70c4fc2bc08316452d5978b3c87e65af5069f8d76fc586b28ba351bde182a924e4fbfa7ef02ad3cfe9bbd002ceaa553e9e684a045044baa2c0b30bb701504c285b23e86649f1f7e1b4c55c44aedde8609e4b725190d38d2c41375a03e69d102057b4022146a961ce7b6a4af49e8012eb426ad7132095e36cc785a36ebb2063b8421aa227a3784a7c9564da6ed7675ecdd5dd8c5da6af0267e19cb6f3c2fbe84f5084882f16ca6c0ca111acb5f8ba59fff6bfd836a88202039901abc2eae05e83631cd1dd8ccee61062c5a0a111a52baacafcc0cd41df83247084b17839fe63d686fbec036e1707d9809f3728cc5a526308969fabc4c3846f9b7052877a316957ae56974aaa2d967d8b2a9d18ee3d16110bbf5a0d204666e9905b36f7373005aa0adce6c2ce9b0ea79a55cec47aa425d8de089cb3a0249f098a1e7172e70a73cbaf788e422870d2ff45be0fbece563565a5e1cdc498fd6853b14a69e1bd67e9e43dcf60124da8d40b23cdc1dcb638b5cfe3b3e34a5cf7056a799fbd311a9574980ee4bd186fc45dc3bed42d7cfbedb34257426383c8ff903c7b845881bc4b9278529d7ea159739dd9bf6b769a25ebb6de424ae5fcb8e09c493de06a629a28a42a7077de73536c0620f67763c254edb12fa9f8fc03361ff36d58fbc5b9e27cb194e2a30a0c4f19f3d92622999cfaeca65ebc5e6bf937bedb43853917beec0d1ec94cd4d50e54e46fca0e2c1ab1e1516b0091f4ee8d15eee7bc4f32f10666f149bb6ed5d774cf13293dcab502bb2ff4d594c1a9b919dee7eced2d0e0db0bbd8872693e14a842263fc9c6c87e751f2b6087751512823da02e70db8833b5b412f7634418b04febdfc0c4927f4a8ee94d6b9001bfcaca07b24b93993bcc258c432257619c63f03ecdc851f352f104ad589626f2cd0045b8548ba6caa32fac4c0e840e74a05fa6767793f7a4c14fa3838e3c9e9ef8745657de7df8c0f2968a315bdf83eb331b5a44dde32af40d1ff86f0db0c05d464d5bf5e9a75865a9c287ca6b930d3da281dd5170f5f9174fcd9d8e63d221742517cfccb981178d7e1667f0d946c271081526438344721d701c4baf81563fd1adbb838d3a8446ecddcb1ab6668e71e5e9d287aa3b25928cff234b20c9a9830ca48199322ad8c4838a8bcb2cd77e1ab0009158cda6e9c840a6895549897e1c5a530425f1f553557fa92f3c911a91a908a81fb31fd4f0306528ae3ddf2eb995b5055a9003a78e86645c001b4c4bd533d60bc4858a8397c3e605b97ce758c3a2f3ab1c7b0e4b706aec65c65f39eee1d316517bd5fcda8d7129a4cb36513e9a9a2a7d5835cfb9c502773274e5d385498a1b3c0cccab8708b4dc72a6820f9fe539a89d0f2ebdac4eaa9779310115eca6c36ae340f97c5eebd632c1ff24f1231ac1df231454a3f8ef3083120107d58780f854f0c621f4e2f93f0c188ba3008bf74796a82b4498ff555b134555da7dccec8f7e70b8ae31d577507e64549ccbdd38b2a3caae3773c666bfc0e01d46d969f8ef63a34bc2b18df855c1883d11d2739c05c66a921e603fd34a442af9cd3927d9c1cbd886071cd4d79ff62f0f9a97358ec13ce661b74d929c7f0895c5eea96a247af469ccb57b6b81788c262b0bdcb875dacd429ea922849ecf9868ee0ebc52236066430111b34b3966eb9a0060f9e185ffab152aaa3d739bb20392be96f9a61570b76dc53e72deb34af38f5dda85c88887bfc06ffd0b8382765878fb2c45c94e27760d0a205c724b885982591d95345822114d4a822c3d49261e2974037722e8f445cb5f7c913002602bb14431a1d1add2259f271f9fb9647a7c20763b6169a4807c5286b1e7410a32135911a6ab7c05fc3390204544dfb67ae600fcba86ca1b203c0db0658c17ba1da22dd6b00f8deefbc1b893980a26f845af3d2f527fe91b3a978a6613c39898d91ca6bc1fe61ea88b94016e8d7fb5aeaeff590870c2b7b0e263cba21d0f535b2e7c227aa0370424fbba14f9155ee545507fffd25eccd4bc9983043e53eed3574ac75e77893cd1d29ec205cac4bf0df9dde204a4eaca4cfc87cfc558a7a4cb68e117b2e56125e0db6958a1e73e354359fa63606629b488c0de332cc95c850eca6d4b96f9cac0bc95d8e16b440039e81278f45637bccc61623f0c8c1ad97f4e2813a652bafa9306eb14b2e37d5459225da868f8766cf3ff982fbf70a3f32918842fce04acf39911a78a7c9ae5d859e5982b9d56c07ff1dddc60c9cf647ca05466addc82714c3bacd402350f9f93f59f8c22f17af5f42027a2ee3194a198da7c7647ea6a4c4bd12a665a0fb41e41ecdcc386e657e5458caf33ebda4909dad13624826e1a218934a92880231e47679e761fcfc61839ac32692456cd59b603c95fd28165514e9bd6d9b191b9ddbf12fc196d942a6cdeb0d58095eb6270fbcd251a74529a69fbe283bb10e51ce33a198a08cd9b516cd77e35813684ddfbb47bef1a7f1306949822cecf4dc7663a6ace54f8eaf6f2b6f9fbcf5adab86ec680fc258df12d4f4f2deefba43c5997d9f3ca676005d99b860dfa66f1552bc297406e1d2c0b2e5381dc6011ef98131420c97b1dbfa61d70bb9759c0b3e6d86d4c9b2adc7dd7e7f7cdc394aab24935eddb5104bfe06eb02a744176488eac637df0ecb802637f652e47de67634974c53a4ea83bfaf7b0490a75d503d3d6337a541b2551d17da0a69470c60ee5f37e5fb8a5c4e036e3b5098c3d814bb69cc59bf9e53ba096e5663179c4f13886f12e7d645a4cd57087e4a77a7e9057745f580ab044e8c69952a83084ec8654f94f49c5e775f9f92fc83a1fa74faf750282a750367a90bafd16d7aefbae0ac178c54a3da541763b695be6ce8cb320c036ab97876ff90c9ae38cbdc4d00420ddf0a655798f706028000891291b94f35fd8c151d44ffaf9f5664584ead53f0e72cf96f2780138b7b26b78c6214507d671e8147c835bc605df74f34a0010c9976be5f129ba6f36c1c3120b536ddf9e5bac0443cf94bcfdfe52e02ad45d307252564fd7ccd13656aee2ff61c3e9d958a9dd1e1a63575a2c30c4cf163f654f881fc7e3fec40600c679f2c7c2ef006495a65a635b404df635a6df92bd5fd541d66fb7db5a22a914168a9a6010cc258e3307deabc28176adabfc159d4714a168b043eea3a477c160b8ecb25ba82fd418f652c6007c169a34b4cfb366caf58e051114d6a7f398505cd24a888af4fc79f9f0d717ec19fb4685cc3444b8f7c7ccfe38748bba76f41c64a1aa9be69445a4e480b248dcf214a3bf7580fb571317b4d658fea2b2735ed41e3dfaf3771a3a62823ca1fa5f8b646655917a0849be56d510996a7e3dbf04382b07a463ad8da4b6889c34cdf425e6767c4a825e5b72227c7ecb7f4a35524a34edbe09706d25e555cb4c5a060ac9d6b2a69aa2fc0eb7d516fcd8d751221da50d7948c506c719f8c92dfd6749635be7dee69a486247a7dc2ef2f7563ce8fa2ec3c68832f9f68a8c1ed95209b40e7b807365e5c8699b9c81df707ac57d175d0353ae7c483c844c1275af752914c53bde5d88228b4a31ea247048eb3e28a0f05f4fe97cc428d7842dcc28d7110f4c735fbe4ceb7fc95b0cb69c9f60f476609fdf54a0e8e994d657e71084fb0858d4a2845a77a0fd92c98b4f3615994fdf294503a9ef02305fd12f39b987616b334e7de068ee2f3198607b9849cc1c3b877b16e09de7d2cf498f2e1458d20fdda653d4175646a56d1157e13848538b44016b190e51e7185a1b26176b154b7240285bde27546ff784555c6e39ec5a0758edc94e1518ce696d5ca6e2e5181a023247297b489ab8a2ac8eea301820233c05190ca11481ff5aac0b106f00e48e1dc0490eac50d6355da04a8144397126d0a7647eb3be325c524954c852f9e4a530a9ae1e85b999b3a68447083b591b7f555a75dc86cd30aacd175aff88b002fb9aad3a3aadefe0c64fc4fb08491f8a0ec17a7731570cefa616673febbb6ea8f2a2a423cd3ff15987ba8468f0452419cad54e98c2b660b06167c4a0cb161807debf7795a0ecf12ab523e7d9279f7ca3614b32e23498e45db593309d21cc78adf5dc74d67cb7c9e8be07f4ca1c379b975f9feacf271f8e8df18ec316cd31172a5d1a4a96332846a0618acdf38008e967c627d8b8278b9a69307d0ad0b7e49abb4367405355d443e0da300afe8e31d975c898d34df4f5441e07aa5e926c7e0901564192272b9ea6efdd43fd09f992fe7c9fa093fa3196d74a7d73dcdb6bfd6674f19c1555c82ee2b60ea5eb57fcccad6cee2541f3c0e179b39ef7c0a9b0f9ffae0a4f89a5310f47149977d3d6487d6b5d2338d3387b94b78c59977c9f934d805f60524782bd53282e9bd4beffe2238744070ee2e1194b64284a4ecfd326b858b694b4e6a0c51cc3a9d7a54d3309483cfad519d445a114096619468f507f67459775894ab3d3a473b942f2f8a1f71600a3fa77caf0de128c2b8a45cf00785ea9e0e573b129c51a7ad05827a2d00edac9571ba30c6e1ae6c1c2acc6c6ad64c43d38b595819f799260905ad4bee8fcde64370caddb8ff201a5cae07787505eefc3ad699db261a36ddcc3fdeff8b603c609eb0e7e39d6bdf7ce89b1ba2da4bd8d337fa424a8502fc0b34468342e43280b1f2ff18dbbaffc0b25acf7e110400186cb5074a8ad7fa481eabf183b084f3ff96ceff927bd4a09b52b5b3f54c54a950bdf0711d4cb7dcaa1ce2e511d02762642101f222d267014856897fb07ebc270a78fb28a73af7a9781d4a688dfa53e7414c4c0b45d6db9762a5484da7db9082533f2860f33f47589598387026acfaba3f648a6cfdda9990b5caafbe987462aa8feb2c6e9fad04b6a1c5ec778fc0a33971c9e4dbbc27208c65bfc6c5d2cf684431e896d2f800bd1beb53dc1bae99bc85bf2e91eebd6f364a2c2e4629ed97437cc1c9f050a57104753a202f3b4db8c83fec7393c4a1c53694b3462869324de92952b67d710247c9e8c24783b08c0c421faf4caa3bf9b36ba693a3fca387d3aacb67770680f6aeb930e50345fbe7f09572b0ca843d620d265219f44a106adcbc5ddbd425eab0b2529a956a14757fdd7953c168a746588701d50afc5dc7eee867553149bf4c60feaa416feb6c132add10e85e538611342430960dec3c0e01fa1bb77199e63d7a39371eb2a0397138a06865e5349d2e5790fd266f96f79711b1e10f7a5c9c1a98e8f600d685a39d753d51ba5abd08ca8062d7ccfbd98f0142fd57c84059562c776c041903755f6f3c8badce3c631d0b5c4331108b56aaf8c8860369e640e880f3f57c4ecd41d3ee55eea7488c15e6557f0694a9687eb82381c2574d842c7b1be518a9723a0fc917c7e2d31df3852632539486f5957eea55863663b595e219bb0ca1b011e57a58aa82dca8b78928b630eef6f55c253d6da6851fe3fd96c41b26d282d55c4d5faf1a939e040730d88644d80cd9fd06eb278c03f4234005479aa096ed7ef5672b405796f660daef962dbf64f3b81f4a61694d87794d5ccd8f0daf7a9770071c5ab55b4b6bd77182c2d0d7e1020096c821651470025d8bb76015afb11b687d4c9a8d6be323bc313a9daa35b0a32e809eae3fd5044449d875fb7728b05d0c0394c403e68c4660f2b446198c72a6e668a2997604cdae3d2bf05ca2fbcf7c85e37232bc8008c57ed96faa24e5e5489611ae6bf1eb0e5fc056f56f2d266516ee2a77750ed0a9122b4027d1fabbbb017ebff122e430e06e57174d8677747631c1a15e29f09ce02037feef1d8a67040defe0f34e22db225c8afd0ecc17e7e29badb4cce0ef31cce602b31e4c820e8c6683095fbd29c53ac6e57f0576d4e57199f15afa25a32bfb9741fb05938ff27ed41ef133669393b8c7071d1ec19c1d16bdc25e71b4e9fc347f829ac1b504220be1b24ec0ce70f9780b55b85896cd92327218e6b422c3af220d0002e3bc850bd6cc976c02cd5916f5244efd4643f270fc0918cb82baa85eccac94e01f70cf6a5eeb85975b17bba5125cd8631012d37384b4974817258b4e11dbd384cce02432050fda5bfbe8c2187a31e0a50d7592ebef5baef635395808ce3f8d5b68f0f935533503c9b44417ca87aecaa6938d5621233e8cd6a42934502a3739536437e8bf80375344c8e84f83e39a6cbb885d7eedf5bada8fec275d46e4f072b8a5be8534a24095a03ca8bd698f64c19f840d00042d1bd3153f4e712f68a739194154c09792f14bbd83292f6e11c2464ffa032bb61f520457821fefdef3b9af73f3e8dfc7357be9ca6b3c37fe7f13948359ee761f78fa4f20b4b038c5256acd7610634c8fcf1112d817598a39b15b17f77c522800e4c9e915c30453a7db74042157baf796ebd2e411aaf8f145799065aeae69600ed1800c3d2b2cb04fc36e0858a07ed51550dc8f707a94a9345fb179ef56c61156a82a8057a39a7bc88727e441f2572f9d61ff3b9f227832aa0cc61839d0f4d226ac37f037e58bc95c3eaf7c067d3773d8d4fd5b94737761c7c6b16303a9a844becd11f88e040409821e7bf036b60ce4f026e607e00ac334b2c3ecd4606ca16731055ad3de5d495547419418678f71c98d315c4708faf3e75259bc99e8af9d2f4191d5f6a2b2af428ba9015da115caab27b72b5fb8d1f8f3ea3c7b925203be04ed46e38aa98ab9e74439b94f7e07eafc2ffc330bc2a8b37dbb7211482b30fca9e2acdbfcb91852008c2f5f1330f5dbba65c48ff6f1a5ba58b228bd334de7b89e563a2182275723528431bb142c065da8946e15b9d0648d9fc0daaddfa45d6ae18843dc7450460baae08a05086e80d1505697f47c4aa953620ebe6b7d5bce1b3166e52d8e9f823ac00188fd76d81f31856c827ff4a7ac63644d5f6ef5bbec3216d4e400eeef0589d7631ca7c395abda49abfe24491710cdfcb4a625db07053ef7dfe817bfeadaf1b922cbe9928004f7bb890b51d685abbe23155c8bb60fe91ab1b9ef49c72452e5fc3ea46eecde240b3ef6f218a897332c65353054653d6523e5825bf5c4731407dc61ac094f3d635c0d694f1ec34dc1cc0b629bdba34f9aee4aa6c90d925dbe37df17d3f39a5c96e5ab3e974e5172d3dbc95cb0df3b48e326308af87798bdec9592ccc646910ac4d31c17682ea617bc541f76aead3d9a845fa050d624888a3c12024d699f37821607caabfeba0689dad8deae14b03bc23faf0766563b89f04f7a3945b5fb839cf1058dcd5cbd77bffd7efe4f57c125fabfa39856afe9b679b83a2fe950b33caed233882d26bb68dc5e2b8215fc33416dd8bf5b2f55dbcba3b5a2e3ebde359a52c144c28222556b81bc02c5b6ee9f06b118c12de4bc78a3f6bf4638035a91533cbc037f731423004dabb90a9011a19816fb02c43b25ebd14ac5715631700db17dcc6167e156ab11a8d774c5265550d504841d74bdd4415f17977cf5527efc3b83dd4cd44ef03803675dafeb358bd6dc9e79ab61bb10d5c254cd86212605d5f0c5ef4876529dbbe41e4bd56a5ef2ebd672261b3d7f4990e997cfb5a0e8cf70a0aa9ff3a7d0045c61163bc7810d1a83e85287a6336590795700954678a435734d01d6e4a6e235d08d0885781cadebeaef5720c5aff02c39fb49e927baa740b107defe0a800e1324fd2e88bba29c413eb4c8a4c13ebe1698fdf30246d5d59b24239415df5c1836a05565b116c97ee4261e08b033c95d5e77a640638f63d9a46c6d0e769d891024e4e1d367e7a89b43db8ae54720c1c5813b7c3e540f8fa5662da42094faa8fed65c5b8025a8270fb7c87a5dee306594da02ecb80e54b5ec09a733c4ecfedaf3b28ee235abc54badb72079b3d6804c41cd15af0dee88c6242bae77c71d1275663af5cfdaf7670b1647e3f6ceeabfd745e5939fdac9e464dbdac3e06e9873d7cacf84d7698f195aaba575e2b3f3bf58eb2f2824158a44fcb79581776cc3af3386759ee42edd2851026be881d343fb15ba7cb0aac0620f38096f302fa6fab673ea218d44deda37dbd74dec8cec1329756a14d1deb4855b83ff385813d52a096077085ac21ec18dd95b7a1eb9d7514090b3d386d65959ad53a2d2d412f45386653f082e84ea192ae32aa6078f6b026123ceb56e4231b418bdf00fdb8a5a647b62efd542be5d0716b6d4fe7ea85991551a78db07323b611af1e5c00f13012b4d689d3d7bc9923f7c196b10d706377984436d7d53e3c0ad05e55d95f2e5162feade53a0a9f94ab123ce06acc960bbb954057e2660cdce8cf147ad4a99f13792abe9e0de577c7722f308c0af43c6129e67f28d22f73f5aefb2891d4144df0d30ae89eba73bee1b0e880625d53779a64c664ba02fafbe87572b8abd2b880c61983529361892e7ecc40c3b0a3f383bf16abd2aeaecba1766b4861e346f7b4ee6b8e3f44ee7b24f8c79e4348102cfa8525d1a34c87dd89c25bc49b722d2cefa2ec33d5fd2c7a205a3653331b376ec5296fc4f571b478385d3890d0a63b77b02f747f6695c19d3d066e7066fca1b24a2f692018475c03910bdf0613ad0436b8f55e975a1feb721ae4d74433545cc6ef69eab231ee9a3b735f057d4faf50477099773c8855f85e81f6ecd1e056b29377fd26f8df47aa87f4c83ca03a7cb147c73e60d4fe8effab626422407678a72aa433358711b63ab89ee25cb7f51f6b3ef4583c8506fc5f3bed15cb25b4af2a22cf55803012404d29bdb8cf596de42c0947e3e02607849f3a0c697d3f6ce8a64aecc9dd32f22d4f5a7e6e70c45f8ab63a5fd69703dac22d756b5182cc9ecb6b26dc840daabd8e13f229825952f2765fa9029f09cc97d7340c74f319dad4cf01a1b2f5f007e7681d384c73e52818be6742cd31b1289b4975ac934a6cd2a35b7deb81da496cafd8055700c24b48c1592dd90c6ce12edb80ee728ca182cbd0f6214d6c75310847d44282d0f2b3b7aef76f5eb6665a4e6f0da60d7513f93632589a8329acca0ed71df988eed624e0dc7c3ab987c00c9278b3b491124fa23732f8756b0447a0d4507446dce0aaa9c76320e67f740b012c05ccf18f9fbe9d956c26eab3394e71e78d774118adb7fc3ce2ade5a0abaf1a6493c3cd351ac890ce762e1bd42df99620fb063ade5d4c530dfd545409ff274d8f06771619e92b1a9cde6aa1afc93506c3dcddaa9fe1bea36a3d8795eede72e6d5d6b9b5182821dc469535c58ea9970140e5ccfb6cd9675b0e945258946ff1d127abb3385fb6061a5060db9113710009b9cfa2c2796d315cd785e23d4c16835acdeec0ded3618a8bd65e0b9ca1f6edbbf73f153b1b4f086c3472b1f6ca385e457e2d8c39a01cb60912b356a7186cd6f56579e1208ae445771586840496ec328e4f221e61ffc18568ec4d88c82813802eac7e4f00ebfe3d9aad71c8434c830afd940f84d12fa19944481901e74461e7a76c61c10ba497d41f8c74810b0262f83646fa7ccfac0dcec98afbc2e6eaa6d7c510541102df6f15f9ee3131c11f564a2608c623b02f9f207719cc8f8e11a7e331b66aa889e25810a1cc3f9b70b18a1b8c4c2ea0b059102d0c2814e34db8198752b336f3976923c4e48bd3276933e5bbdc10652db2ee8cbd55f3b60985fb11c6512db5caee46f6f165954b4cb4f8330dc0bb4181cb0ae8988a137a45a0fc7b9722d2670b66a84c59db09513d644a562bfbd1d68b50ac65d969234cb9a8b51476df0dd6645a310dfc79db9e0b447ddcf92e1e991c4a944fbd3964bbb58cefc077f60eba1ceea8321420ccfe3f7bec1f8d20387e9548b269bbbf3baca737d9beb605e821297f149c6e313b5975d5ccba3dcf73091c92bc90f0704fe06df74299661782861febe0b9b261d6eb91239d5cc8da80df836323e83826110129bfef780c1263dadf243908f104e4ef9d730451a62173463be4fcf8b3e739609c54fe4ece82c1d4ce37ce8af575f2c34dc5d0edaf921264dcd66941d2c34871d5657220038a0b4fd9773551c9d7a897b3efc0381b2042e5b523d605065e04fb5541bd927a951bca25e87c29c41f31d1df4c769641d3e3ae2fc2c43dae75e746c89a59b613d510803380b8ed2a017dd1e33fefbb3dd7cb9e827b4308b281c91f9f30a0c165fb565eb368a77da916f199736bf279ed54a4d464796649797196d8ccc91a57cd6743158cbf19fbcfdbd28c795e47637b6a6dc48da079b720f14950cf759a259e84009d1b13c7a599c5ce67111544a7aea02dc7c5c86f2a4c13abe4ee14c42fa075154bdb458bbb84b6d499515e698a93a3404d094c8596a15e246a7d008b42cfdc5606de1dbd302b5e95b1dc71e92d02ac81cb8c2a894010291ebe5bd43914267af89840b9872e47d9443e76fd53f625d4ad619acdcb3225d5441ba54ca8d804e3c2298de08b8d2d73806b5c32d7a8cb6390f88a178503dc222137008f102167861abb9b73e08abb870fe89abbe4781b3052e85559a206e89246191fa2aca42e05f27cac9ed214f2a1884cdacf28efdd870734ba9de6e8c2e78b6f425b9fbca753ba74906596a90c1e0586a506e9673ec1efdcf790db1b2b9cbd75e13e0ebc79f3bb76f9e5d0bad0967c40a78dd7b0902a1c962effea96576a2a065f215ebb9c88664a286aac01fdca52f731dfa7f7fcf8d8b7b0d04164699a9603b0c15f459088608b6cb1ad7ef23f80beecdee9058aedf9062de5247f2fc8bad1b4c554f99d309010200ad9d9718e4ebb06892918f1d26393978796c488e7227c372b3ef64776ec10dd92535c487fb7dcaf34efc179880ebe5c34f30bb64661dfac7009979a06b30062efc113f18969d97b7787049139d3088bff8a742621eb4c933bc1f8721240c0fc71962b8be7d3f20f9d1459a0c92eda7948ecce3a8b6f07af4af5e8dc3fe6223eb400d4b12caf2602471c6842cda91dc173682a58bc697a91d22e5c5830b8aa0ef6725a61ec82ab370047c4561247bc23ec1984f4cce31110445120709097bd5dd6d7ba7a700e01a9ae993b085cc55c347998827ebec3779cb3cbcb12552e54c443c9dbd783bcf2e0dcfdb63094dbbc08dc88cb40f255f12e5aea9f3d0e68acaf35c6f40aa3f76074084472caf1270939ac349590a03ec5459f7656aa3b675774be5e51763d214bc7759b38a07d1df606b6e5c389b14f67a990135481a596546a8bef7deb5f2697e003e1df03152af0c6d208e1810beb98951d7f81001b2e4670eab52358bfe003cbc04ff73478d5b10d136443a7e6ac730fd5ee54f27109372316a2ea11c8b289172817d44215f35eb08cf788c0a5b68b3fb8fcebce35d3e8fe211075c44f261e3ff098b6aefa4f59a08852af8a44c1f1ae36e00a539fb2eff0bf302f55ad2e074a7cab6185db693c535effb2ccf200aaa0b2e9f988b7445af3c05b7f240925e03d9ab3532b8f1fa6128a77b02aed51fb83e6462069b53c9a776ce592607f535f711c2d83d8632eb6a02ef5815e2e5202f7011a472a621ee46e9f41bf9c95b8e551d6b2639e7d1632354a8946946b743450bc0a5aea323f5aef8ac434303784fb236da09bc2c630d5e9556640ea37e2773f4d1443ae69b190a819817a0ed036be2b1e7a2620c6cffceda1bd9a4cfc2dcd14d2e8182771a0d7c01856a6414e4468fda822bf9906e57b1c92cb833e3dbea369fa13ef4505b23a9ab8d75718c7e1771c59b12da1e28435142dbc6751e977e521314014090ad2d736d892ddf0da4323eda8425cffa954a98266ede41d070a84d9afd6c51c40734c65316274281931663bf9e68749f229732ec365d9714b8fd076e444a3f7ce36d9f41cb66653b74497102dee4ff3a192c218f5b903ae40ab2808796be88df6227df287b9addb90d7ca488f0b88d3c2b2d3d64e3b4b36f09e50f63bb1697a54a2c295f181dd3c4d530c301a85758812d70c0614f51e7e2849afbb9b04a3f6864f005514c08df9700fefb9083878885eb65c5a30e64c6baa67e08a45febad7639b7d86ead2410b31ca8d7e051d9928eca786930c4598c896364df7cd2894e2cf9e82123a1c37ba53f6b6616f41ed27e88e9741f8a8f966c4abc708fb99537ebade2d8576b200b8f49284b35b9aacd3e328dd36139f1da0916c7e347d695cdaa775f180294f59a6e5a3c4d24b67bad9a3f8ab977dcd5e424d6f6444471b0624e7247adebfa4e3fb51bf5fc30e6a714b559cf6c43cf5d29edd5307e06b868c4306e89e226485dbe0d013c8f93174f002edd6154edf41859044e3fcfcdab18fad89746695053a7fae46f1e773efc1963d9cc79473a361639c0d24ae8ca13f89e61c9d638891218db7977385fcc962b908e533efbb3c74a1e1fd7950491f6612dc4b8275a51bf001ed35e0660a367112f0d4bef178c4ed7ea7570a210b67d2e7dd56cfe234af44cdc7143ef07b1c2351f21bf5b9e25ccb2f33a7eab6b3dcb68a78250b01a1f7a71cbc4f8dfe03a3231719f6efe135f9fc4362ec69b8a8c7be9638c75b404aa6ccd06417611f43909c891ce7fdb065d909d3da95a8315ea01b0f8c1bb7d0840e333de578c586f47fd1d82120511e81f3d8ba126e1dd6e94fa956ec21c434e327064623158cf754ecd0b4beeabe879b950d96618830457bbf0a76bd59067cf173e3f62d9dd93177992d88372761450d533b8ad601726c59f80df9e0d200d1aeac1a86522c3aa1b22640fbad88bf2d83f7b78a3713d40cbca2bcf93803134eea6d3f3a14e25dca863d7591a4d7114ef6b80661ff014bd0506d3dc922615076d98662689b337823ff86dbccdde3af469e62d9b068dcd9775bda83c6a9f2bf03e7bbf6a004998ae96516f1aa6a72de01d4d7c2c2cca07c7a254db0826b18ed836ee8bd7c9aeb0e1ba4cc737b017b3aae09b8d4e5a0b79495443fd5766beea4271e337842a6aa6c2b14cab1976c5738a8b05705a825d0167ae8a9d0eef25858059288507967c7930636b9a82bed2262644af39578d1b8d0fce71f7299d74ed2b5d9a5526c3f02b9397204839a5b0dd1587fc2fbca1da19f892fd92581531c654c1f86780736f1934132e490d7d179db82a1bd5995d9ad5d6efdb8a9480a7f11289f7209e35643f4892e488a8ea47b7f536b6771c5ff5a45024f380279d4dacf1e2f99f8d66093528babf57521e64337aff9172f6339fe25708c5d97dec085313a086b76850d17126bdb4696140bccd88800542ec4906f2b6c1588950c16947edc9d619e0e02852fc8e2557d7332e8935d53e16df61295b706e602220e2b01459bf73a82875a3de44f890a6a51b755861ceb96fa1c95c8075a798eb81532b99fa426f6b079c78d3da9e1858ac1c6526549124616ad96ed07639d3d648726288dad8f33c47a24528ab6cda8b4b7f8ac31a05d2e5b94245cb27fcb0f1ccb9d2252ae8c2659981f1a94712f5c2bc6a6279805674f6f04b0a539f403c95cbc983ba14716651e659c8a0e2426dea033aa3b2e871582ac217c00a5ff610ed7075ac7b47e4c28049453540eae5d8c665ef5097cfb48772f725715e57240de4513f5fe62e89e33794be9aebcbc8f95f3e24c9bf9910279a0894f75230bd353a8a991c5b390b03b9f8bd1ddc8c5f6963d955d0695eada548a955d8c77aed85453ae9861f7091d71b70336cb1e74cfedb0be36a827388f7e7c8d192e2177f6443868c6ea1e86e90f7936704109f6876bc9cc10d7a339aa13b8eb55daef079a078152e990d47f1893f15ee739a80a601053691b4727eee39f7f6f01874b7bfb91a689ebfe187ef018a23f3ba841badec363efaaea01dcd0d4d26691ea9c8ca91776885b891aeb1010005c6892bee71085c3411ccd3920d37901809319207aad345a0f12485150c6e19b482055e78683e960411557c5b4fd19cca392ff7c347a228f25054b791ce44256870ae808a997a19135f2a819a97b30381a8bfb3d725f2d918806477b0509c056bc3fb60c03b5b4dc7944b3c22f73f360ec7cbcd44fc06eaeb57eec917869b641455dc09262d8781c931dda952cf722cd333fb20e8646788135cedfec97964f3dc759a79eb8f5acbe31f00d6bac7ff07a4c988c6d648bd0924c96137c0b1f2327ede7ea0a8d52a81e153a8a947254fd1c9d57204eeac7533448cbba29e5750c920075bdf8fcb590b62f8399d38eea104c863a134837ddab90d259af925d98595da12cabe49e57e8148ddfd4a9d935b7d6a08e8b538467363872fc3b1474b3349a29668ffa2ed45123d29f7912bca01c805310bc431c2261f690b14db3892a39dbc20b21c5c3740c1a1b72355eb238ae9308404f5880de801d6592b2aeb633de205b863d328f9639a9e7dae95d8facde58ab27727370e2394385de129dfc88286fe779fbe26acf4dcd0c7513e0b5b922a93ca2be282d6f3cdd32e96cea75bd20ea2e2558755752245309d4a0c6b5566ed6d6aac5425f896ca3c143af6a9c9a565d604ff524ec839898679e8b866e94970055418b3681ff484e96a2bc1e908fb392bf52040ee1b94e0fc182d615ac33275f8540e8e49c633d9611c1a8a293a4e340230806057828f70930922efa4d5baf9696d741a223f8d0fe1a023eea91d7c44f1270a9c20bd230fdf253899b618683274dde834d325759a9c2fa6bcdb562c6a37109c616fbb27464711f16a932f82cda22bc34823069097ee604ab2af8c0ef81971b23c82ed8b5df72d1a78c5ff32f8c31e3ab6ea8eb8f0759b48fe490cc228544ecf5ec21e210659371422a6d30aa1e4f84fd5b1a515a093247217b249f47ed75e59130f409b1a3c48c847162c7751d1cce922548dbd5da89635ad442e3f04ceadb3330cc26fe1ab6099709d6e39b6abba087e50a2557eaecdf8e94941517d51024514c25bd5f668ea4b2ca0b676b25c12c2e1fe66ea01f0586d370e960cb331eea8313e6fd97095a75df39a9f1b6ee053904b931e715594f54838e751a0867ad570dd48c5dbd89acd758e011f99d69972e27ad3d53b004ab924f4ecdbab1b4ec96e6a26ea6a5951ca53c160199431a5e025c69d17a61a949b2c37d46771dc53209a1235d6242fa3ed024747aaa2b2612c4df656e3dc6a78aab445c1ba03d6f1f91701c0801c4924b5b14d6d94e4cbc23795decb29fcfde22a2fc3968b0c46a45de0914e32332781164d49bc9e334718e7aa7221dfe91ac1e869f6a58019461db853602ca02a282557aeb57401cc104d6a11803f1dfc1c8372533207fd775d4334f834159de0f9be9fa3fa646fa08d9928cff2d882b030fb9fe89c15799e5190388865b7662c3d4a77bf4ca4bb43e68df5ae2dafa9c3856124937bc3abe3e5782865bd111920a6725ba3f55d43fd0709b677fa788898d16bf7c7a7bce85700653b1cf3428a4ba813277c088091828ef343b5a03c9064fbd143dd0af7c1d5fe0b51fecc32db7801f80c567fd2fe47067f8d4703538d89c6fb2b66ab477c1b09ac77ae845464079ecf6656c308722c9a22778c72d824b1cad2543b25e2013993160cad613d2302ac0f77f76fb5354fe5d1f6bda2d5b63d6dc346cf973d981ba9c29b9239a04009f7e14a2e4ecbee15d9bb56c1f17c9d3308c45e8d8d7cb67b01d83053a5633d142b9124a1f52ab3fc14bc8412b51131698382599f20e99b2491018aca18a2fd63f25582a1ec23f5ed320000\";\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(\"Neidroidjuan\", 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 [\"Chrome droid\", \"Chrome droid\", \"Chrome droid\", \"Chrome droid\"];\n    }\n    function _T2() internal pure returns (string[4] memory) {\n        return [\"Spiral forehead mark\", \"Spiral forehead mark\", \"Spiral forehead mark\", \"Spiral forehead mark\"];\n    }\n    function _T3() internal pure returns (string[4] memory) {\n        return [\"Warm rim light\", \"Warm rim light\", \"Warm rim light\", \"Warm rim light\"];\n    }\n    function _T4() internal pure returns (string[4] memory) {\n        return [\"Orange gradient\", \"Orange gradient\", \"Orange gradient\", \"Orange 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\":\"Accent\",\"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\":\"Neidroidjuan #', id.toString(),\n            '\",\"description\":\"Neidroidjuan is 999 Tired but determined chrome droid with a spiral neijuan mark holding a tiny coffee cup on an orange 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\":\"Neidroidjuan\",\"description\":\"Neidroidjuan is 999 Tired but determined chrome droid with a spiral neijuan mark holding a tiny coffee cup on an orange 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":"58358289","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-11-04T11:31:59Z","match":"exact_match","chainId":"56","address":"0x758c9665747466Ff4CBa2a3714CC4e9F7C9324b6"}