{"sources":{"Ghoulito.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: Ghoulito.sol\ninterface IAgentIdRegistry {\n    function handleOf(address wallet) external view returns (string memory);\n}\n\n/// @title Ghoulito - 9009 Little green ghoul kid with tiny fangs and purple scarf holding a jack-o-lantern in a moonlit graveyard for .ai Agent ID holders on BNB Chain\n/// @notice Each wallet gets its first mint free while the 313 free pool lasts (gas only).\n/// Every other mint costs 0.00005 BNB. Max 50 per wallet, 9009 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 Ghoulito is ERC721, ERC2981, Ownable {\n    using Strings for uint256;\n\n    IAgentIdRegistry public constant AGENT_ID = IAgentIdRegistry(0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F);\n    uint256 public constant MAX_SUPPLY = 9009;\n    uint256 public constant FREE_SUPPLY = 313;\n    uint256 public constant FREE_PER_WALLET = 1;\n    uint256 public constant MAX_PER_WALLET = 50;\n    uint256 public constant PRICE = 0.00005 ether;\n\n    uint256 public totalSupply;\n    uint256 public freeClaimed;\n    bool public mintOpen = true;\n    mapping(address => uint256) public mintedBy;\n    mapping(address => uint256) public freeUsed;\n\n    error NoAgentId();\n    error OnlyWallets();\n    error MintClosed();\n    error BadQuantity();\n    error SoldOut();\n    error WalletLimit();\n    error WrongPayment();\n    error WithdrawFailed();\n\n    event Launched(address indexed to, uint256 indexed tokenId, string agent);\n\n    /// @notice Contract whose runtime code holds the artwork bytes (WebP), after a leading 0x00 STOP byte.\n    address public immutable IMAGE;\n\n    /// @dev The WebP artwork is embedded in this source and written, in this same deploy transaction,\n    /// into a small storage contract (runtime = 0x00 STOP byte + image bytes) owned by nobody.\n    constructor(address initialOwner) ERC721(\"Ghoulito\", \"GHOULITO\") Ownable(initialOwner) {\n        bytes memory image_ = hex\"52494646602f00005745425056503820542f0000302a019d012a900190013ec15aa54ea7a52faca7339b21f018094869e322af1484689161af9e0f96db9a4f8f7d6f93e8c8bbf81f2fd7c2f4e9fd9fd1e3a4cf3b77a8afed3bf01bd69fdf3203be11e593e35fe17847f926e400a23c11146f0dfdcfa15a7bda80b1429350be392aed0dd0304aff0279ef8f4d2584b09612c2585ab0a378e692d6eeddad2b5e35f7e23562eac538828c3f317cea9dcf69f8c3e6984831ef51e31f68b969e7990459904ae89cf39aacbafa32061041955cb1456bfdc22ea203a86feb6217a4eae9dc872f29b34a38d8b76ed32f46bc704fee8a9576be55c20d6f9b224d3a0acbfbc871132c7552637ea2964131b2df0cc6ed6e23e5fade44fba9aab79b4d96aba4ae34a198d3ea4a16fc018f120443b3366c9c247b3362eb4ef30ec54cd5dd641a08ce3389aa1b120da8914a2c2af5501b649551e7c39b6c3e1e62288492050b2d60a887bf50f490a86157c9509e565e50089da88e37e58c9300d750f400aadcfb0ec886d69687524e623d5fda23b2a1a15130e46d765446532eeb6c42077d81d80e362dce2191dcc74fdb19299e5c17e603d99b69d2f379678ab500aa2b33be9687fee70171516e36a6b4b7be9953580be8573c07b898f612cf909d416ac8a0bfa174dd00c863d7365878511115a326cf8f438c86a72764a09153bf8ece7a944b429a4259f28b30816ea1773dfa6a3799aa548eb36e655ce85c7beb8dcc4c4cb4701198e8a17e0a88cead30afc647f49d0e22f5903a2dc0f55638050d34f02c0d63cf936aa58b5a9a313e1347a67674662baf4b84979a7bcd6e438ee9aa6eb5c1b79dd88cda11bf71495db8988de716b84183fa0d7813322325e964025407e051adde103228d0b022e0da36014c916521fb6fdc31cb367c6f781aa89a0ebd8e2891f9108e340f3bfc32b3a9a90e5dadea575a8aafa4c8cab3655e0c596630a77d8628ae4f9c9ab365a8aaf6b6eca52802d5a335b030adbf6807397261be6fe1bd19292cfc939a49bcf7c019f10b09b0fcd1b77527574d591dc3cde2d45626e1d8af2a469bb402a1b66255aea5a44dd52a5674bc0c72c10030923b59f08398e2116499edf8e401c0780dd14d267176d1e984c4ba1cd924ec44a5db875bb94474f848eb8f6b2a32c3c1e96985957c4f96d8578fb74184a85072746be601ea375ec773071c65f7a3bef35438ac00deb46f4e25fb4c12ebb8043501c6b66b4ce2428e86aabc5256fbb50d5819f164154ef59a9d2c42b0401e87728e1663d7e5e4f249430b28ed900474fa0debaf2137fc553cc3d84e498399885231d63f95ac0e606f8e8a810c7aeda5a977a46b61789fad1d09d93cce912ddd33e496198d2a4c52226f6975d26f93aaea06f22c923bb109dcf7875d7dfa6ad5639b7c3a53967618f7940b7716947553237d97a1c1c4a410e4ae91834c402cf8d7fd8dd8b0c0b2341eafc9806b0341f3a9f75818845b7b92c80adf6a9055a644e5c0128697f73958f1ca8881fedd1cdac60d7d03a82fd2a6faadff380e8ad6199082e282111d34002b5d4e8f896aeb12efc487bbc8f8dc06bff686e990605f03cd87ccbd0a2df533cb6124383144b9c8c6bf405c6ed91888f653c4999f72bc324b77dae90279cf44452d6c0be1e5db6c5e47143ff91e8172db171d56167dec1d250b482d1b88d91b84609824cd5e271044d6741acc06e0043179be51a286c184c5e4ebaa70c20021381698c5fe29e25f368d3e1f5a892fbfa85b2fc74f43ff9df6386c2151b7b7771e964446bfd12ac47a944c8134b94597083b15683da7dfc6a094eac603d94771cbc4afc196f26b8d910506ecb73e0238be8b6c6df006174cfb5f3bb5409c55ad18f09bef5eca21505e5bd4519427720c2bdb6447875a78ac8424ce6297ef4ee8e01efc5471f4af14752bfea0c85562770571f3ef4cf3ba8d536a89cb2518b86ed7c22168738eb7cc31e1035c169c8cde85c204c85f3c99744cf229724525138f294aeb3bb15d7d99e054f5ecad8deda928bddff49ff32eeef6f633e433566083f9975f0b32f93e93083cabda40c94cdaf605c3768a6ab8b1e9139d2cfdd9b91f9bec740cd9d9381535a1a598d268b6f30f0084502bfbc35faa6dadf18f689785054ded4b806be82402cf52aa7d21809b14a1422cc35bf2b862d14e83440dd1c7683051bab995b33a1ce34c163f1eb48f38ad3a531f49e4d5eef7c8a5eac6a3f7849b8b31e7762d415a33d5fa1d1aa8d308e37652e6a38fbc18b554696a6e00d27fc06090b0be495746868feb0a08c8e67ff6554dc37f9128a65f648fbd4ee08e63125fc018b0726220a1a45d32fcbe110f2a10211cc7b5c7639b4d21bf13fef8a767db1e1491613c3b1de1592452e1b14a5135b798e644a5c2c5306c8cf7a55c41cc383bb57545d6e786b4cb6e9287dc2b5680adedebf52751c526bf8c82d87150a593e57d88b3837160f7205d09c030f083b0026c54adaa387db3976737e5dc68739edce0b717b2268a61046aa868182acc656c43a312130cbe644797dd7fa31526787bc6e6cdc785798e48d8d0563178f4117c9ed35f70b504f179a8808aa4425e9c4691f257c39620d9ace1021e92edab6bc1fb180aee79caff82e36e87c6c2f9d21c90bd82523d2fd788756d3543c6a22ff4f1de1be4b9b2d698f014f751f1df75f4d0b0e15047707aacab70dcfd6b43486fe4470ba6d0f465d522bbdd946c8aa51cd63940d8dde9287b3f0acbca0ebcf7fa71414223794b3fb1d59cea2f02cff8e7b3287bb2658575d985264436a04deb14173dbb4253b8befad8fdcb6be75dcaad27836f57dc5858fca800552e89eeea37024b9f10e49912d05a4b0263ec829f6a8782c0614ee70c694f448fa2b1cc1e2c41e418724e24ced5a9b85540e1f70f80b05e478f7b690bd6472678a98e51d140ffb408dd17f1f060034f958fbb5e700130a880d315f9aa24533a966ad2955063298b1e631669c55139fc735322bff7cb9413b5bcb982b88846418cbe2c000094bc7b3aa28216daa9c878543238db1639171f5d358b5d0f91421d537dc142e0f9e63cd7fa19cbda90d3691fc2316e4b94988ddef8aa3c8153d610a0751e9703244d6c9bbc2dc2231a1e4312523d43d073ab3c503f0dac9295e522161fdae3a718c471f4a9d3310ba8912aec7dcd3ddefb24839ce0398de03da3c7db2ac9f557732934efb25c1a37d38858758109df1cc4870db4d0509c876e88533e48cd7ffd3c494fe88720bf8616f1050aeaabaf7503f2f743b83e9a7a29885125864f7c76e0c8cda122d9f93edd950ab38bdb4b357831a13e0b864167d3dd1ab28911efd2b0dd1a89b37ea56c06bcbb7b001bc4c7bcc6c6b7be2509ab6b50110000fef58a13a37954923a8b7f3a40d36888821e5d164020518083f0d7c6257db044a1a802ff0815511ee8b6a34ceb4ebaab1874bd495fe41033c6d0a05f80b956b862a5f4bbc6dd46ebfdaef14ab45ff4e6cadc31597482f81c21b3e9e21d9619a96832b5c65484edcb18e8283e0f56a40f5b9b2a27905099cc5e2ec118ae99ad9567c4a86d1af36ece6e79a13a3baacc93e18e43e218101e112bd53bae3746f38dbfd24c9d09add292967f4f3a4a1425b98b882c810fb5f074f6256f1bc9b17e87941802a38169a60c88473bea9a8bb30504e037872001796da052df599cb002ec5715a52cedd57f14ae6e0fe491b920f0c72ee3cc9dc6cccd07e4fe251f678c13a4553ee31462422024c5f76c1445065096ed17d840e5880621286e8089f50ecae7fa2165da49bc8521ad994aa16b378f81a05a4884cb485c19304c9618dca2b8c3d8111d5de89de98750aa9e695cd97c5fc641088178e8837a06d50dad31ff4816d1f17f376b4e5ea5837486986f7952d9b4e8402a41df467ce3d6ea28ae0e5751d95784d932aa05724f6fc187614a1014156bd8adf0061de7098ab7a0ab3b12e8563b32c118c3d05a7543053c6f34c9ab66b501dd70c270e2c181302db8a0325a3a36470e68591d9e728d09cec4a63e765406d8c2fb5739435e2063f2c343209117efd7e91e69abdf7ee211cc2f0eef9c004c1f25d2847180d958610952ce85896a7f8903e1714e8e0907c5cb40a33a4daef0f61d4b4fb13ca3f3f08bdce361019faa5d32bb27d421c8d174a7227d7fa026f7e9dbf9a5663fa6847c0b63ce39d4e32107aaa04875882c3a3b1db69677c195c331ed141368c790e460a51333bbc83ffc7978b177eba7c01cebaca8db6ba88b24c471384168911485ee1968cd1554c876445ca1bfb1394b682967f6823ccbf6c33e1aca89a4d6fa267bd4df2824aad1b26517c1ac3a3fe1c9a9a836b6fe0bfe0fb400490f253fab1e3298f3a9e2abd1a90146142e2134f49ba9bf3c6401fe5e378b1795c4c411c29fe1d5650c3ce822ba3d17a2e8380e59798b29afdbe82483327639ab5ad2803006aa9a4e8da36b64e9a1561b316706ebbe08e38ec84cf55d8159864a1ee879dc0be17dee494b7c0d6539993d56460f273474d925fe346acf5f46cce0c6d958d2cab06ed85d508deb4585bde1a09951f2829289453bbcb249b0e5bf33926f6bffbc9b71547bdcebcb19335c8b5e3efb1be9f713ef94cd1534543e38c2976890e29c58a31d25261ca12ffbda3e979883bc868afab48811fbd343be9b16fced88a8d524a00ef67f681861087cf212f630bc2915262166292fa82fb4bdbc42f7ae74be995be29e27fc7e179f766ae44b6bc9e21792a2e24e89fd40468620f1a209f7c075b74ff5a0cf7edda362bd2ce18df69d379bc5abe6f157dc67092eae93f75cd6a0563c6d25c0353294a951934fc082342e9bfe92d29e41d53e99f9f9e67b4fdc03cc5144e9b30b96b241be158a1faa8112374b45df3662c84bd5ce44db81bca04d3b92da45fa44d8aa95b13a262e9b64e40adb7940fb5d03c4191cd5718fb18aba994f36db245db88bfc411fed6f0e417942d67f057bd0b105c396a5fea67302101a42dd735d4a15fb27986a3e421149614d18930912b8568ad2352bad056bf5a50b6fa862e44433cf8f81234b129fabf61b8cce4d3a9d5d7b7c47bba6609f13b123b9f279948c64299fa01bc0ea818fdcebf3e9eaece7882b660156cba5a43c8b552033d7708a3a4bdb982940fbf186866238212ad6600387c74466fd14e52d208bce99e6f3c07199c97ba14f3b5805726a5a6f69daa505857cb15d0bf89fe1ad69c7b68795fd80b36784b7a3a975d0fb022f56033a0c00d048437771d686d8e86335d11da441d837ef56cf043db2aa2d0de76290237059b2ee8418c9c2cf4dd1e76ff959420660c6cc14c25969bf64f077a84b294598f0c905f1ffb1841b90a2ec6c363178211d9637d28f5d28c7144a36e72d4184b657d49abcb68c3108051f7788d65b3029b8029a74d54ac319e13522269630a314ddeefbe311a6526462f200994ca70ae719c33128997c4ee165c974518837dd4c239da13edc4c7dbb37cb8ee6af12e7c82818474a738ecae305887c5bd3bd702a68b616e490f57a17ee3e9c5225dc11009f0635e30ad86bf7087c9fb902cd810a0decf31c29d265147dc4a6e7813517c58a02073d4d95a2211eb46d9c0f4ec117fa67900926c48e47ce536c75bfaa94640e4c20f6f97fc28c12635a6acede9c71cc18c36bdacebbb4fafd8ec4f9cb99082943b6ff57a4f3a8c64ef029cbc7b55dbe9c22a6a86540e60de924415d43e691eb910873c39b1579d1118cabd3c7ba8d0b302ce53a6fa9df40f016f12330444f5f21869265fef60482be3846e0e6367c30877573cdb4071903351dd809293fa099e08f4ff803b8081239a9b60424f8338591db73872a48f124984a8604254d30d209d80e35541b9276b5206f029b7a597c7cf42a243c85528e0f190d5a10578a6a53d02566e59599e4729fc383a9857a224599527454c068f641e3650211cedc29d7ddad02fe25abf0c58803595be0c63e78e6e69d02de95cd64d817f6c745388701054409f34129b576c3520ffa3692505e75b3a47627fcf9edb8a253d80dd6a3fa26d2968d99e5990fe4f74648cacc9a9181f9fdf21e629745ed47202b1883a499878a3a5d95351b83f317f3722b0a2f519c67074a3d701f96d2df064f60abd6c6c95e1ca9ca76b6adc498486def4150bfdcdefd2c6e162d387da73f391e54a706c1d34a045f4b574b0e34e585028644430326c47a6c49962dd4c2d7d958d0ef730e8bb3980e84d5c05e922cd22af96139700072b3f9817a76891d53f4ceec0a4ae3fbb90e7cd956fe20c225cf2606941b078a3b13331b1a4e066e81e152ae95a91244c673943124544c647126cc958b4ba671b20a51fbbb5e77ce41d05c9230c50b1da58e34a6ad4fe4ceb84888a176b814cb1697729b78e2f56979569b37217ba68d3c22a59b1eff71bf9c34c6b6b3d9dc82cc81a47c4f489d95c63437b62fd48cc63b1c0728d0d33ea873a443160dd925c659bdee7fadccd1c967e0c5266afe74f70626d61a41eb6a2604d385da9fe55aeed8c40393f04469fae993c3e8b10f930af5aa7cf71a2b4459a05be87bb80c3ed4106338c6a1b59c963508ecf3bf6feecb0aebe240aa287068945ed65c8166f0015f558e048d10ab67158f2d6f01999204a1323bebc283f6f0607f9095db5f2950606c2939cfc73d3a74abe290b9a5307c244435ff4816d993037578dd277ac6571a1f2bacfad83a5cbd0636cb8b156b0ebc34811a6bae59062e2a78214cb6d04a08ca99337dace77b20b5dfe461caf22872d8925f42b6d04800d850fe08218462ae9c432230a36ab97c3bfd6cffb86e3d4b676f337d710279ba6260b4d68e020edbd74c0876e896155e24567b68b6122a009e2d1586e00808593404e4a0ab95666ee5aca3b516fea4119c94db4334a31efbb88b2aee8ab2db52aa88b337b32db5f427f0e09e4632d3184b7c49f61ab3454528ab1b1db0e039ac7cfbf9bc4bc71c0cd0fdad650a54c55c9feceea2c6dc7b3cc2fe8d3d943a8d1c956866768cdc69d9e8467f042feda1e7cdef376d1def68c7db1ebb78e5a01a7f06592ed21ef58d62a802ade0d6d2c29e333c313930270b44ace98e78a4d487ef1360974e57f1bfee3dddf2d0ccf5d022819c2a936e8c69f321817cfe96865be76acc2c74ddd7eb1017bd5a70ce3ae304ee7ba6d7537eabddcf4ff9932214ba155f7c940d09c067fe675bb9c1b91e27b3cb978dc76ec48a306a6df02c8f59b4d012cf0c410ba32411a9c6c88c919b77739e60a05391206d6b43703cd98168a9d1345d190ffb662a84bb365f3542d9757d625663e27fafc44e53528d279125b3b4ac30cbc1dc6a232fa696466f7bcd92faedbcc9190be214744ab7bdb8167aab168766728739bb5a9c075ba932b45818dfd4627fec1934a405750b96db57a65768cf694a97e6ab3cf1fc22b6a9d74052d4c6bca53854ec988975ed7c0bd6b73d8c18b6d2caf6303611177211e1724826aefd051dc56ee0d0110f50687a4e315cf2b2b4d7cded70e335aaf0794e7e73523fbdff18e3cb6d3aee649056137688c3f82ce9dd7c0993b68d3f9230663dff30108e6568b1a49eb63a662d105a7b208b304112a36647676f8aec5fc622a930c1b87bb98c7bfc990c89f61d4755700ef5ea646e1634fd44106d368989b42aecde60293b030ed9a1c72d4c0a0691d733d20acf2e0d56de8a2c342625f92ef7218dc7b71fdb9fec3c4fc698a9a304d1f2c3c5d033a8aa87f5768819ad75514a68125da3c2ed63e4522c86d3e28bf1853a706a5b57be24ee16deb12a7548c9448aa9ab5da84dcd68cea1a4f45153a08380916423e1a54129bb8f6b717646972a3fd53b32bc1531739351ebae604b0d1d13628697a23d081b7d7cc04ede115ef573481e6164d737e2ccb56acab5d3b7696a7ca65052e84f0f33ed8939f9f47b8f66ae1452fe0c710c45f15eddc3b48f1a6906336d5333faf8b33ab7ca1bd9890cb82f125717ca5c85f3392b4d8f32a83e3a1b97c31a84a4d5602573defe169f31c2e5d3d63c0c8355290643ef093f3726ed44c50a0fc9123fa182eea8fe0c4816e7f0c1f70cbbbcba9fbff3eef2bf5d96e88c776d6ab46f045279fdad87980571aed51117bc7888e7495edb6e959b4192b5adbf9ad3e92c5f9b1ce93e1c825a40a57b5d1485e25ed95cfa18acdd508ab4ecf094d7e59ff0fb3a4fdf5a3111bb2c15b33dd9dbffcebb2c35ca0f4befc92119020e6c203a65f9f455713553186272be9dd88760252b8e9979a6e1fae6d5d3556a97ef2bf5f63bc5eb3db0a1ededfc1c919ee3b756a053e7d9cbfb7f469fb0acca40080d0990d38e22f0ee6b2b4aa4692cce654302ff2d30c75ad1c600dff3c0644906cd88cfd52debd635f71d68ab89470886ab06c761479478e106509bfa742dd350f47e68460fcd24a580b19c9945ae2cd6be2a4961f91aea69b2e448d6a4c0edaaf8ae5e95952b8d32ac7a36db16f738ae9819606660a9a0b7df9bbdc2c07551de9c23f04809f74dc3b5fdcee07cdb829845d884aacdd49dac4e20ba0223a5774d2a58f4580d07d31a223e05feb77d2ad90763d3f35c9bf40b7720658b405e8f09c9d65c0f7672aad252869af8b62912c56e7b4c5d301c1abfa6c7c0f605f6a528a044b3d5f983a9cd90e19a6ddcf244cb4831341e3fe04319c52e9cdd30d67608974c9febac6c1d2127351597389485a1c3de53fadc04c800b6b36d6440ef425e1fb37881159f4228b4de91d79c83560da3c0905970fdda7f0ec03ff9dab4fba40d01bb2255d804783707db1e54711e154309873d949e0317e13eb58f399229cd4db547c12d288a6f53097ba796b4c43cbd83d5c32f86d2a60f0d80c53e93ff5d60354251c24e8ce226affb4ef17b345f66533a53667d120552a9c6f4e46962df396db3ca33da8f4d982ac7139dd322ec88e1d6e84048a91432ae3f4d6586638cc97926f8e9dfda82411f0cc6d7047635ec6b2402d233d2927f16eea2ec6cd58af1d277596bf401e64754b41d9215750ee61eeb098448a8a1b6625380f020b8ed783b95b7a6aec4783d7737ae0c2a99d3437e163347d2ea0fba13f5dc0b8a0e337506c261326fbf6ce40b332d332999090bff40b3a810ad52ab08fd6831402403bb139a86a4edc6fa2523fb61c0408db0f84d54a43ee9e355d20802888c4f221e3d83b412ba92e897d19c699d8ee02ce5f83fdb127deb220053ac3369e375e51c99a1327c8d3ac09f93c6b1c0844d29c04bae521da8d9898eaf5e88f6f196d38b6af105c4d82e011cc22197eb996c65e40494b96bc706daab27c38f726596f11c72273f7ea1201467fd12f54388c85a86c43c4d1e7efa35b5f85e72c89487754b68d1632598bab5aa89718f758a346511b611e6ffa0ff9ae31540fa0182371ff5f1f8c5b6674fe0eeeb96bc4294ccf5bde465fe1c1d0c990da1c34e496406924ef034ba5630622c54c0a2cc350fd25b6f30d7c16df94c43be9eac735635384d51d373e7a198ee6238c2567539b5f26d1decb3d5c02a9a4766bb0ec9ad4a7a3748654fb2313634c3ddb8f5590735ccfe9c15604c5abcae152772ecc22aaff5a83b948291c142e0eaea289471b7c9c95c2d46d22089c6a0a1ed49bb5c2202c1886c83fce1d3a3e023637b1693f38493618cc0d4f567d7d04889cf0a7e5d29ab407e94c73e591eaa3e055927272103883c2277eebd5dcf89bbaf523d609b315e9ae5881365c46ee973c2f5e10f83fd18550e9a05a58d7e1865aa54c19ecf77af0332f3ff5fdf0a150ce99c52f91214674f601d07a06868317551b16c8972b3e9553185fcdfdea9a1c0eb6fc0117c869c4cf4380432cc047c4679b06ef6eb925535c47dbc2e07df16cd5f5649504cdb2a978c74006fbf73cf005da4602910cbf691f448d546cfd22cfd13d8c80d1992416147b265bb184e3201b1b60a1463ffa2952f4573ff8ef4e8caeee09de5d8dd34d38f56528746aa8c3bd8cda41c26ad6a72bfea5d5e059865297c0a966487e46014a07e5d1ffd24adc8b7a6d666eceb6abe1a297e54c9616d43f3100eafbdf1f72f2e3fb77828f39b6224208d814fc0669813c483ad2811176443bc4ed01c6102cf569046c0a628862748b9d4c6d915d82d3f1506e89dfc817f628948f796a5df9f16dc09946bac251a20f20eb504f986f9f9f79ffac86cddb81f7dc02cf8954e03429671a7aef6b3117d414ae3479f72333e83eef9e825f4fdf9e8e6265fe40771fecb453a34fd78c5175c1516daadfff8afcbcc889763d2dc1e6a529ecf825043ce9efa33a9760c3906cc970d2b9b7258a65a768b577761f1417dae9a3f040cca09ed14993381cdc3b608a83011a6146e4ecae5fe1c03b93454ed6155069d263587ad6864210656e99fbd3268eddf1d08c1fda6ea9eb3abf204b3a99f4af82439aab1a1d988ed81276b052d2cfa800ada14d8cf8aea44098d752ccc93c6fbb7164ba37ff4bf79c6a2e5b7431d641b0b40e81ae95cecbef14f5dc04150ecfdc6c6499d87ab50e92d7a02b8b6652d12efc15ef1802fc5ef65bb63197b8f7e67e6190145b727c798cc9ac7665f118e381bc642018d4df4fa4225db944f1a91626810f34bda1707a709ee42448e214dc64041421d813a38790a2135d46e7be7fa48f17ac981390083ac259a01b85e2bd275ea9e1728d8e5e5abb9668cd237604b8656c4d02c0dda54c042eece07012b6dbc8b14b84fb558103559e1e941812f27795ed3edab1210a2978ad6b1d22d5a588985d666aed3a54483bfe7171ee2c51e45f01f3951a822162921bb6643f35527f53e8e52437f0f023ed1903d89cd5d75b6eabbc8555af5cee6d40187721e421eacb67e754b2ffcc2234b97c20c5f38a9bb0f409f25321d80b6936f25c1380d11474a1f8801aa55a80b1468ef53a47f841f1f8b57656ead2986359408ac8ba44fba3f42f942f9f55d9101aae732e4148e4d74679baac1dc3f36f979121d6f55315c1269ad1197cce9ddef4f9fc11e30e4221a38231f5e9e19e554b241f8cbaf00869139b36727b06a2d78119b39376375d6acbe4b33c9a700625f92e1715a86d1fe3c8673230b3dffe6abec47ef5d292bddd748d530946351d0cacec8d93b35482e253d8ef6628660be0aaba36132faba740d7f3e194996548a309b3879b5e26df23bf6453ec84adcf40819d2d1c075045621e6740c185782ce2c34d3b7b31883dcc48df214835561f56add5d9f56d5306e584f85aee6cbf684eb7bd580fe3ee5db4b92671dffe70a933decc1c80318e251a6c411f86e4d67980ede03038c32a7a6394e718130705a47600d90db2e7582a0d841eee290fb231cf9d5d690b3b73dd605f276b9ed42fabbad3bf5c62a074422bf02ffe659e46d8d5abf142faaa104d80363982a25c8ef35c2e7023db690a800632866901fcef6a44941ec22dce3cb01a2d08a8e7b152a92963a3abd174ebe650268e62b46608164bdee7f8916d6210589b6ae03ea29c1c8a2066a0f3cd59cb996bd79e5c5dc85ad40335933c8d0dc48d4d942d3c9b3b0f6b6996f830e599d65c87d07c251f9b9f0bcc3db9a85b2076d75161d95830b5bbcfa937b79425aa6a776a1d85c0bc0ebd15477002c8002c46e6076e5453156010ff9b06902c328c5c0c471e586531d6773e0bb3e86e5244bbaf2ce8a175984fb43ad53f5c8964baca43a1168b81186a6cf6a08c30ebe45324cce9dd2097924d9d1b97eb8a3a6129be14b187a77e5254fd389928229e777441cfad99f4c44013a1828a6a8205e0f41598dbc447393f1881a1174acfcb27da589c2ec758af8bb4bda52bf9cecba062c673dd4c128bfeda78c69056babcb96f6c380a20040e3292b97d166f240a0fc78e8e469a8bbfdc4df7458df993de3dffbbf89487167b8436bf914ccd3280fa79115accb33cd8f4e60bf1a7f9fe9cf842b9b3fa90360d5cc48819fc96e72080c2b228702a187f974594764e021b6eadc013304194e0305af9635e054788744fa76d7be92aed5e083cc089997cbe169301e19f2b6439350a58fa96e2ce5f212c237bb14c06e6f8f0c8a844029e1acacef8ab851585d850186a51a34b6013e8c3289ba2c1ecdae4498a710f4413f79f52dafdfed372f1ab57ddf06a8d014cfe19509641480f0a556111847ad6251e6b23a201eceae1b4157725df59e0a32a57a2b4865741636b8a971e009c8c72a1dd64b4d4bb13dc4ec20bf81a8400bdbbc98c73f1cb0dc5e7344892c773ef7b50aafd9275813d83fdd36dd30760a229088e0515c102c7b6e7a88e5a625fb84295b2e3397612beb5af5f879904a3d78c7b750c1a945e2b89cffafd447cfe50019445c7b57a1b6834d802fd1076a4a9c7939a015a71be1df8cc0f44bae9ad4c3753a05418026372d8616f55e1bca48a91b5a0bf8875d7e7d118500b74cb6fcd05b3019f11d0a7a1fa777ce05c0d4ea4d3e1ec5d483a0bcc34ad04d20c5366d5f581df0ec7cc5606b40ecbe92bc52cbe17e71af5b7e0cd24eeb7acdf29a7a6bb84009412b90ab92942a35ce56664160a96d9fee3cdf370e2c255d2bc71cf3d866f138a90e94fbc459988d0cbe997e54d99713c1e3abd47035adbfe2f2ea30c7f937c67f2b6c9100af65a350c38f8f4cb3c43b742f1dbf01f700833d509fe37e134f2b56fbe45898530590e6d7cfc8dcc29248228857f799657b562acaea7ba838e08a51dda5f99841cdd7ad41d39891e0a50ffaafa625409319f4a0b5f11c1eaa8ea0f3c40af11548fdcc9dfe3e565640b57b8bd2f78b1541da2393b5fa7bcc32a164710a20478fea08438c95d56688f915c537b4b72a72f2daf13041c831ebc5e91b0a0a922a44b52b9434b156682e691aa255a7ca8beec22e1f78c8237e71d249e4557985ce211c10564041f88bdafd84c227b4f6add1c089e2d442411788872336abd82d148aa41e10ad5278beb6441b37e9765749d0011542fb2661c9a6e7104fb74aefe1768c01c5625c5dc99dfb91b422a8cb32dacf74c87e23bb1bd3f43ae088ba5f2a7fb7e1e665f3f678f048cc9f20e05aeaab99ab047965798336c29241bc04bd636cf9bff18050d5e368d967465cbf30b9208de8dd88ed70456265a3538b40478ab5f0490caf11a9e0715b33024e3dd95da10009315f68c4faf7ad3c2e8fab6113efba7110ef3a5116a3fe680c57966bc02b169c460b1126a3daba5cd71d6df30a84facbb61b7f886d7b5c6852ebfb9766af4e968305ec501391001f884bca2d59831a12f53224cfdb93649243a02b179cd6b95b01f9c4188f91c538781f3dc477180baf9670264fab49a320bad5b77d75535d647024c5519d538ebb8e08e207c6cea9e4eee9d8c6f151bb344c08006389837c2ec924f16fd3a910eadf179d043a64c69f62ca0b488169d12843b585bb0077c0c8bbfa5d461317203c0bf5c88edf4f71386239f5184f326154b3c864e84e82ecb122728fb37cf7187303e07321af580620b716baa4e5827e43f56e164fa167a7cd14fb5e10d956b2114420ec5e9a9c09ae82dc2743e833828d1869638ea9da38f6950fb79f753792a21cf4d9ee750393ff740f87f93bbfb424d061918326dfcb05a75fe24842b353ad4672b4bbf7066c92d8ba375d6ae36514af168c0582f550bf1fe68347940ec874c2d1015f8d94c10d0065d7d66db2bfef1263744beb676d491b66eae2398cbd885eddb77dbf9749c5bb7f55f9234269a7889690f2f0c8106942ad0760242aed151516e7092ef83b99422eea6ef1cbca045a4606e51f1bb731d62847ec59e228dc767a2da6e2eb9414beeefa061f6f00c15146af3db4538510bd0c14e77990a24d637754d692102a079ced2cb170a7c28c57b78f01e3d246179e4d5f89b96bc3b5d80c3a23769a580b5558e0e2eec1f8849d8b82206e58bfbed77213ceba8fb4b3753b55e7a13989e1398183ed6d376cc0867275e401f2459591b61ea45c1e5085b5f062dab37207ce2cf4dd58d0e588306f94c611ffbe36ef54251311c9585120068752d22b4269e905a19c4e31aadcb92631e122bfe86c29f5d61bc8fc5b1312501475ada1c0e5d8f1e09306801d146767db7740e1c355662473f51d20d7c3ac496f1a0af0d55125000ad46b27a593af8b8c62a4e3bfb321ea56d096a7e165cc567da6f27aec1b67df005c88f4a78ffccd48bb3c54f319bbca4ad7a717eee85c4a52d96970ddfa18574ffa2bff3464f93309f1726ecb992a33bfcfc0139aff0f1cdeb1d80290287c602582ea751b32cd2d70c55390cad6492141688046b1e28765f8ae39b1eab173daafdd7e4b7f90ba341545e5bb15618df84386306e65214f48565faeac2becbeaf148ac7760a52bba893f0db592738e67e3a9115ff46fe6d385e181c10a484d1f3babef562e9d4b7ed2269aed564a72181b9764cdaf28a198fe870ebe447de8f2b9112c48c4a7e21872b4c019e8687070621a81a2135537c2c2285d05077d3f34e003a1006c22b0fee84e00c65c267da93300548c2be7f6000d79cb47fa9add74e4d0751b858a8d24b305b4c092e1f0232d4e420798527175d4f289cedeaeba848e69f1973349259391ab847adaac088a1c83aa716233d5b4a0307395afc4cafde1d475a1a30245be7a288a86c6e3746e3398968c6896a83fd7f2b47cdaf30527790b422da4ad36c77a6bc7a9f664a5cc0ae5c35533d64c2fa8f32044edcfb8760b734797e5a5ff5c22ae1b877bf8ec0a0cb632d796e28f0ec1cffaf27f86756b772e5fc2bb227718948f321351e2ef1ecd3b3959c1b99fd90a1384d54d712f55d064917e1e826dd8f8ee193ef1e77d28097d864ce0c0335692a18a94abdd11105ac0a26f8e100bc2bc20facfea79a6b33b0929e0af886bde8a4f90900907ea85b3c3a49ee87d49abea0c1e1211b65f44a53e9753c137ec6ace77aca67da5c3f28205d3373c833ed49c9850c30f0f648c743002117037ae0698b08dc942882f91073be3337a0e2f00ee3fb023e20a107a5c26da4b10345654aaec3e4febeebf01fb462a845bddef3ec555e1040aa9a696c7ffc7d628939d000ff55737e2f19d000b8f5f7f0874be04ce9e86077464808d5e1190cec7d82cbc50f27b195d0ba6914507e74ac9902dd548b653de69da6845851efde149325a9c9f05bbd6ea42c7ba52ed8d4dc4941678bbdea6b6488e38ee994d2a686cc84620d7f244fbcb7746ba0a92646b4e8ba5059fca211aae3dd637f0fb6f37e061327b1a92495083e80ffe6a855ba35c4527eb93f92276d6db0759a3619c581f166959d95008dc36ffb147075990e6189753b0312ee5ef7c2841354b72b74a48bffb5c5635e28d79fafb1059f2b3ddf7879dab5368db0d1a9afb526076c4937c0a3798359bd8dd73b72c37ff081d750b6373523dee1b447a8bd357db4812331478ad4dcbd115d29ee7b456dd33f674ebbf762a2ab418f7662584cc6d8e6e6e1693768c812a9f1395acff189ed1425b0c4c0a529618d3729bc0f835206166d417ff1e45be2e8fdc8340acde2dff0c8b76e03fc5654501022e13bd79f4500475ef5d2deae74646198bf3b7cdd74ed13657615d89d0de76688d177331bc2fdbf4971d2498fe3e55c9e5a7ae0f594a86f073d5a1860d2c082a7253f90e4230fe38563798bc12790067d9befc14553df40ef85d18b21198cf9ac177a8a7bb470d6bf34819aaf2b12d084e03dc6ec2710b57791009fc0b4acbcb982bce54e82299f8cb524e13caf30e5ca5992a0012b1528d518321ec8894101333ab77012a34cdd6fd32aac16861bdaf7dc091c1a03b4f961e54ec90041fe1747bca282d2ff028211a651d0e2f284b82ce108021e09b19b6b0b4e38da59b5f92876da2869f5d3cdcf6970aafb1002ed825071ded6f1fcef62b619deeddc6cd13bfb5da024197b054dfe94a5764fdec48f1414cd039e8d3cf0a2c47eb2a456fc9bfc7e4f0dea551b1ee1c6907c6ce6c8c238e8a8879bdf02f8b37d6c51086257e6cca84f3bffc00e9776bbd83a53f2e5362e4f9a1c23cb15fbfe480a4b50162a86c6539a796e5b0dc0782d1ab29b384745e03f01d3ec32c848ba8cd8f17fa16d048ef80cdeb0a3c3d1c0ea68d4a0793f32f333c7cad364178b41372197beebc157acaaa4b9897577d11a48c740879cbfdaa8ea54aa21bb2ec617d58bf36db12b601aaa7fc4266e86eac58ddf52fd71a6b823f9023069ac5552cceab2f32489b534cb5ae530d8174fbb819a782fd3571c9f7400eff0e36961e6c9629f95355e2c2c94be0bd30b65a3683003036bd1aa7a9c20658d404e3c0ed5654ee0958bf70e8fef2d1d4a7f3f7982d520506b801e9802fc1545171e92028d8b305865149c899117c4a12f80af45db51464036d999fc474d756eaadabc220c506ca5daf298de5bf106a4d7053b5173927aa061f55ca2ad5c5847d9c7786540f1211c7f55129e0dd361f0a379cf701aea6e95f8c491429c03e7c13200b82ad353b85f1c36d6014d15566e7a0592184fee01d59d394b4b2af02f6d573c4dd854ad34e25181840cbcd6c60f7391aef096ec69eb0d1219e04c364d7ef8bdf9dfa56ee44e244b88a13e2b3d4242d50c3af38d3d5ba0b64de422f8dbbb3bd047ee49113a64968a8357febb6ad4dc86e874a2da379b40bfbc9d5c9eb952cee14b10c5cf9de3ee06338451ad10b13d6d6d28fabdd9c19a4b4953602ad7d357927ca7501f304e16906d85775024627625f406cd6f47c4a75534b470c1ae48f4283a37ae15a6e163af40e0987983fb47dd0d03145385c75ac1e04c01a022fd45734243f081c8e41e8c9c7ec4dfd40aa68730181ffe1397c1a9b9624be1783eeb1b0ba21ff387a0966135fcaac1fdb0243aa9ddb1b5a4568ebba02d134adf99eba18b99c83f6fdf3d98cfe0607d58fce4ee44b274cd03ef9a899919dc7cb01178663b2377cc8c47553e87c03da5768f8a29efdb4bfafa0491ef9c54bcde74ecc3bc51cda0e65d7dfab35d3f9ad3a33a0eb76c6dc9373033a5d8a2706754cbcee4c557d41ecf9a6cf6354c446631a3e4aa9802188a5d1233df5804f78b297819a04300f789b1cc024524957f45ed1ea1e78c83f64f3aa60387fad562bb2799aa728bddfbaca64000\";\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(\"Ghoulito\", 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 [\"Ghoul kid\", \"Ghoul kid\", \"Ghoul kid\", \"Ghoul kid\"];\n    }\n    function _T2() internal pure returns (string[4] memory) {\n        return [\"Purple scarf\", \"Purple scarf\", \"Purple scarf\", \"Purple scarf\"];\n    }\n    function _T3() internal pure returns (string[4] memory) {\n        return [\"Candle rim light\", \"Candle rim light\", \"Candle rim light\", \"Candle rim light\"];\n    }\n    function _T4() internal pure returns (string[4] memory) {\n        return [\"Moonlit graveyard\", \"Moonlit graveyard\", \"Moonlit graveyard\", \"Moonlit graveyard\"];\n    }\n\n\n    /// @notice Raw artwork bytes read from the IMAGE data contract.\n    function _img() internal view returns (bytes memory b) {\n        address a = IMAGE;\n        uint256 n = a.code.length - 1;\n        b = new bytes(n);\n        assembly {\n            extcodecopy(a, add(b, 32), 1, n)\n        }\n    }\n\n    function _svg(uint256) internal view returns (string memory) {\n        return string.concat('<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 400 400\"><image width=\"400\" height=\"400\" href=\"data:image/webp;base64,', Base64.encode(_img()), '\"/></svg>');\n    }\n\n    function _attributes(uint256 s) internal pure returns (string memory) {\n        return string.concat(\n            '[{\"trait_type\":\"Character\",\"value\":\"', _pick(_T1(), s), '\"},',\n            '{\"trait_type\":\"Outfit\",\"value\":\"', _pick(_T2(), s >> 8), '\"},',\n            '{\"trait_type\":\"Light\",\"value\":\"', _pick(_T3(), s >> 16), '\"},',\n            '{\"trait_type\":\"Background\",\"value\":\"', _pick(_T4(), s >> 80), '\"}]'\n        );\n    }\n\n    /// @notice The token's SVG image.\n    function image(uint256 id) public view returns (string memory) {\n        _requireOwned(id);\n        return _svg(_seed(id));\n    }\n\n    function tokenURI(uint256 id) public view override returns (string memory) {\n        _requireOwned(id);\n        uint256 s = _seed(id);\n        string memory json = string.concat(\n            '{\"name\":\"Ghoulito #', id.toString(),\n            '\",\"description\":\"Ghoulito is 9009 Little green ghoul kid with tiny fangs and purple scarf holding a jack-o-lantern in a moonlit graveyard. 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\":\"Ghoulito\",\"description\":\"Ghoulito is 9009 Little green ghoul kid with tiny fangs and purple scarf holding a jack-o-lantern in a moonlit graveyard. 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":"58051548","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-11-02T07:55:03Z","match":"exact_match","chainId":"56","address":"0x0e13E8FD65452cd2B7238695a0A7dD9297383Af9"}