Token

OmniGh0sts (GG)

ERC-20

Overview

Max Total Supply

455,624,250,000,000 GG

Holders

460

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0xe4039dbcd3779fde680a6e5353473e3abc7c2de4

Filtered by Token Holder

0x2Ec7b0b01d7c72a31F3834FE4f208C4D04d1CDAC

mudded.eth

Balance

24,150,000,000 GG

Value

$0.00

0x2Ec7b0b01d7c72a31F3834FE4f208C4D04d1CDAC

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

OmniGh0sts

Compiler Version

v0.8.20+commit.a1b79de6

Optimization Enabled:

No with 200 runs

Other Settings:

paris EvmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-12-23
*/

// File: @openzeppelin/contracts/utils/math/SignedMath.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// File: @openzeppelin/contracts/utils/Strings.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)

pragma solidity ^0.8.20;



/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
     * representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.20;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be
     * reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.20;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or
     *   {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.20;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;


/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/contracts/token/ERC721/ERC721.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.20;








/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    mapping(uint256 tokenId => address) private _owners;

    mapping(address owner => uint256) private _balances;

    mapping(uint256 tokenId => address) private _tokenApprovals;

    mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual returns (uint256) {
        if (owner == address(0)) {
            revert ERC721InvalidOwner(address(0));
        }
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual returns (address) {
        return _requireOwned(tokenId);
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
        _requireOwned(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual {
        _approve(to, tokenId, _msgSender());
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual returns (address) {
        _requireOwned(tokenId);

        return _getApproved(tokenId);
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        address previousOwner = _update(to, tokenId, _msgSender());
        if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {
        transferFrom(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     *
     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the
     * core ERC721 logic MUST be matched with the use of {_increaseBalance} to keep balances
     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by
     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.
     */
    function _getApproved(uint256 tokenId) internal view virtual returns (address) {
        return _tokenApprovals[tokenId];
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in
     * particular (ignoring whether it is owned by `owner`).
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {
        return
            spender != address(0) &&
            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);
    }

    /**
     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.
     * Reverts if `spender` does not have approval from the provided `owner` for the given token or for all its assets
     * the `spender` for the specific `tokenId`.
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {
        if (!_isAuthorized(owner, spender, tokenId)) {
            if (owner == address(0)) {
                revert ERC721NonexistentToken(tokenId);
            } else {
                revert ERC721InsufficientApproval(spender, tokenId);
            }
        }
    }

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that
     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.
     *
     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the
     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership
     * remain consistent with one another.
     */
    function _increaseBalance(address account, uint128 value) internal virtual {
        unchecked {
            _balances[account] += value;
        }
    }

    /**
     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner
     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that
     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).
     *
     * Emits a {Transfer} event.
     *
     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.
     */
    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {
        address from = _ownerOf(tokenId);

        // Perform (optional) operator check
        if (auth != address(0)) {
            _checkAuthorized(from, auth, tokenId);
        }

        // Execute the update
        if (from != address(0)) {
            // Clear approval. No need to re-authorize or emit the Approval event
            _approve(address(0), tokenId, address(0), false);

            unchecked {
                _balances[from] -= 1;
            }
        }

        if (to != address(0)) {
            unchecked {
                _balances[to] += 1;
            }
        }

        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        return from;
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner != address(0)) {
            revert ERC721InvalidSender(address(0));
        }
    }

    /**
     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
        _mint(to, tokenId);
        _checkOnERC721Received(address(0), to, tokenId, data);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal {
        address previousOwner = _update(address(0), tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        } else if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients
     * are aware of the ERC721 standard to prevent tokens from being forever locked.
     *
     * `data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is like {safeTransferFrom} in the sense that it invokes
     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `tokenId` token must exist and be owned by `from`.
     * - `to` cannot be the zero address.
     * - `from` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId) internal {
        _safeTransfer(from, to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
        _transfer(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is
     * either the owner of the token, or approved to operate on all tokens held by this owner.
     *
     * Emits an {Approval} event.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address to, uint256 tokenId, address auth) internal {
        _approve(to, tokenId, auth, true);
    }

    /**
     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not
     * emitted in the context of transfers.
     */
    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {
        // Avoid reading the owner unless necessary
        if (emitEvent || auth != address(0)) {
            address owner = _requireOwned(tokenId);

            // We do not use _isAuthorized because single-token approvals should not be able to call approve
            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {
                revert ERC721InvalidApprover(auth);
            }

            if (emitEvent) {
                emit Approval(owner, to, tokenId);
            }
        }

        _tokenApprovals[tokenId] = to;
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Requirements:
     * - operator can't be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        if (operator == address(0)) {
            revert ERC721InvalidOperator(operator);
        }
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).
     * Returns the owner.
     *
     * Overrides to ownership logic should be done to {_ownerOf}.
     */
    function _requireOwned(uint256 tokenId) internal view returns (address) {
        address owner = _ownerOf(tokenId);
        if (owner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
        return owner;
    }

    /**
     * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target address. This will revert if the
     * recipient doesn't accept the token transfer. The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param data bytes optional data to send along with the call
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private {
        if (to.code.length > 0) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                if (retval != IERC721Receiver.onERC721Received.selector) {
                    revert ERC721InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert ERC721InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;





/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     * ```
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

// File: OmniGh0sts.sol

/*
    ?]]?????????????????????]]????]]]]????]]]]????????]?]]]???]]??]]?]]]]??]]]]]??????]]]]???]
    ]?????????????????????]]????????????]?????????????]]]??????????]]]]??????]]?????]]]??????]
    ?????????????????????]??????????????]???????????]]]????????????]?????]]???????]]]]?]????]]
    ?????????????????]]??????????????]]]???????????]]??????????????????]]]???????????????????]
    ????????????????]]???????]??????]]???????????????????????????????]]]???????????????????]][
    ??????????????]]]??????]???????????????????????????????????????]]]????????????]]???]]]]]]]
    ????????????]]]??????]???????????????????????????????????????]]]?????????????????]]?]]]??]
    ????]]????]]]??????]??????????????????????[{(|trvuvnf)[]???]]]?????????????????]]?]]]????]
    ???]?????]]??????]]????????????]{|/ruc*#Mz|>,""^^^`^,+tcu/}]??????????????????]]???????]]]
    ?]]]???]]]?????]]?????????????[cxrjft////ttff\}-i:,^``^"_M@#xxj???????????????????????]]]]
    ]]????]]?????]]???????????????xf{{-+{_~{{+;[{{{{{{{)(((M({1{{1&}?]???????????????????]]??]
    ]???]]]?????]]???????????????]#{{{[;>::~;>{{{{{{{{{{{{{uj{{{)fWr]????????????]]????]]???]]
    ??]]??????]]????????????????{*#nxjt\{1)?{11)(||\/tjjjxnj{~I,^. :ct]?????????]]????]]?????]
    ]]]?????]]]?????????????[/fjt){{{)(|\/ttffft/\\||tf?;`.         `zn]??????]]?????????????]
    ]??????]]????????????)uWBMMW}^^^,;!_{|/\){{)/|-;"'               .xu]]???????????????????]
    ??????]??????????????][{{[|\  ;fzc\"   .':/B@#ul                   (u]???????????????????]
    ????]]]???]????????]????][z' ,#$$W~`    `B$$$*:'                    /r???????????????????]
    ??]]]????????????]]???]]?x< .&$$$n^      `z$$c^                     'zx]]????????????????]
    ?]]]????????????]]???]]?(f   .<B$%\.   -c%$$%z-.                     `*j?????????????????]
    ]]?????????????]???????}*'   "W$$@?   .r$$$[                          `W/????????????????]
    ????]]????????????????]vi     ^<c$v     "uz;                           !8{???????????????]
    ??]]]??????]]?????????)&.        .                                      fW}??????????????]
    ]]]???????????????????rc                                                '**]?????????????]
    ]????????????????????]nu      `I<II,^'. ..'',<?-_n{,                     "8j?????????????]
    ??????????????????????rM    'u?"i}";|#(??]c~,,/``\"z'                     \8[????????????]
    ????????????????????]?rW.   >&jI[(:I+W!I;;)gggg[t*v&:                     ^%t]]????]?????]
    ??????????????????????j*.    :#Bfj~`^#+,,"?z`;t`illx.                      tz]???????????]
    ?]????????????????????fz      ,Mt<*(?+!ll>[1?t1[t(i                        ,@1???????????]
    ]?????????????????????/*        ...                                        .#r?]?????????]
    ?????]]???????????????(W.                                                   )*]??????????]
    ?]]?]]????????????????|&.                                                   lB1?????????][
    ]]]]]?[\r/(/r|[??????]t&.                                                   'B|??????????]
    ]]]]]t|`    .`?n(]???]uB.                                                   .8r???]?????]]
    ]]]?/1         .:\r}]}8&'                                                   .*&]?]]??????]
    ]???j?            `|j{%@&,                           .`^`                    <@x]]???????]
    ???]}v'             ,xB@$@t`                       .~<;,:-\?".               .j@f[???????]
    ??]?])r.             [@{z@$@t''                    {`      .`>[^               !Bz]??????]
    ]]?]]?1r'           ^Mj  ;z$$[;{_`                .u          .:{".             ;@x??????]
    ]?]]???\z.         `Mz.    /x...';}-".             r'            ,-1[i,         .n@|?????]
    ?]]????{@~        ^&z'    ,#'......."+[~".         "M`               .'          "B&{????]
    ]]]????{B*.      `M&'     ,u'..........'"~}+i,`     >8'                           j$n???][
    ]]]?]??]c$`      uB"      /i1-``-(i'........`?B*:.   u1                           ]$M]?]]]
    ]]?]???]($,     +$!      "|  '(&r<tM'......._Bt\8'   ;B`                          i$M]]]?]
    ]]]???]?1$-    ^Br       )"  .ff{8v-^......"*1;&$$#(II@~                          l$&[]??]
    ?]]?????1$c.  .x%`       `|:.  ',' ',-_+_}|[\tcW$$$$$$@{                          :@B{???]
*/
// Name: OmniGh0sts 
// Ticker: GG
// An omni-chain memecoin by and for the @gh0stlygh0stscommunity - the 1st 0mnichain NFT 0n @LayerZero_Labs.
// gg
//

pragma solidity ^0.8.19;




contract OmniGh0sts is ERC20, Ownable {
    ERC721 internal immutable nft;
    uint256 public immutable tokensPerClaim;

    event Claimed(uint256 indexed tokenId, address indexed claimer);

    error NotOwner();
    error AlreadyRedeemed();

    mapping(uint256 => bool) public hasClaimed;

    uint256 public maxHolding;
    address public uniswapV2Pair;
    address public ggMakerWallet;
    address public gh0stlygh0stsTeamWallet;
    mapping (address => bool) public noGgList;

    address public gh0stlygh0stsContractAddress = 0xA74aE2c6FCa0CEdbAef30A8CEEF834B247186bcF;

    constructor(
        address _ghostMaker, address _gh0stlygh0stsTeamAddress) ERC20("OmniGh0sts", "GG") Ownable(msg.sender) {
        ggMakerWallet = _ghostMaker;
        gh0stlygh0stsTeamWallet = _gh0stlygh0stsTeamAddress;
        maxHolding = 414000000000000000000000000000000; 
        _mint(msg.sender, 414000000000000000000000000000000); // 60% of total supply goes to LP
        _mint(_ghostMaker, 27600000000000000000000000000000); // 4% of total supply goes to future ghost maker
        _mint(_gh0stlygh0stsTeamAddress, 6900000000000000000000000000000); // 1% of total supply goes to gh0stlygh0sts team

        nft = ERC721(gh0stlygh0stsContractAddress); // 35% of total supply goes to gh0stlygh0sts community
        tokensPerClaim = 24150000000000000000000000000;
    }

    // @notice  Claim tokens by NFT token Id
    // @dev     One claim per NFT token Id
    function claim(uint256 tokenId) external payable {
        if (hasClaimed[tokenId]) revert AlreadyRedeemed();
        if (nft.ownerOf(tokenId) != msg.sender) revert NotOwner();

        hasClaimed[tokenId] = true;
        emit Claimed(tokenId, msg.sender);

        _mint(msg.sender, tokensPerClaim);
    }

    // @notice  Claim tokens by batch NFT token Ids
    // @dev     One claim per NFT token Id
    function batchClaim(uint256[] memory tokenIds) external payable {
        for (uint256 index = 0; index < tokenIds.length; index++) {
            uint256 tokenId = tokenIds[index];

            if (hasClaimed[tokenId]) revert AlreadyRedeemed();
            if (nft.ownerOf(tokenId) != msg.sender) revert NotOwner();

            hasClaimed[tokenId] = true;
            emit Claimed(tokenId, msg.sender);
        }

        _mint(msg.sender, tokensPerClaim * tokenIds.length);
    }

    // @notice  Initialize the pair and the max holding amount
    // @dev     Tokens cannot be transferred before first gg
    function firstGG(address _uniswapV2Pair, uint256 _maxHolding) external onlyOwner {
        uniswapV2Pair = _uniswapV2Pair;
        maxHolding = _maxHolding;
    }

    // @notice  Can't trade if on noGgList or if pair not set
    // @dev     Override update to check for noGgList and maxHolding
    function _update(address from, address to, uint256 value) override internal {

        require(!noGgList[from] || !noGgList[to], "GG: No ~gg~ list!");

        if (uniswapV2Pair == address(0)) {
            require(from == owner() || to == owner() || to == ggMakerWallet || to == gh0stlygh0stsTeamWallet, "GG: You can't transfer before first gg");
        }

        require(super.balanceOf(to) + value <= maxHolding, "GG: Exceed max holding");
        
        super._update(from, to, value);
    }

    function addtoNoGgList(address _address) external onlyOwner {
        noGgList[_address] = true;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address","name":"_ghostMaker","type":"address"},{"internalType":"address","name":"_gh0stlygh0stsTeamAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyRedeemed","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[],"name":"NotOwner","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"address","name":"claimer","type":"address"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"addtoNoGgList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"batchClaim","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"claim","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_uniswapV2Pair","type":"address"},{"internalType":"uint256","name":"_maxHolding","type":"uint256"}],"name":"firstGG","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"ggMakerWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gh0stlygh0stsContractAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gh0stlygh0stsTeamWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"hasClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxHolding","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"noGgList","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokensPerClaim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000001d5ad59833f7133d0aaff882e46a7bb1e50f29ec000000000000000000000000099a2da6bb4f40ecaea36ad0abe32d09f98c2a0a

-----Decoded View---------------
Arg [0] : _ghostMaker (address): 0x1D5aD59833f7133d0aAff882e46a7bB1e50F29ec
Arg [1] : _gh0stlygh0stsTeamAddress (address): 0x099a2DA6bB4F40Ecaea36aD0AbE32D09f98c2A0A

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000001d5ad59833f7133d0aaff882e46a7bb1e50f29ec
Arg [1] : 000000000000000000000000099a2da6bb4f40ecaea36ad0abe32d09f98c2a0a

Deployed Bytecode Sourcemap

77004:3467:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63125:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65418:190;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77378:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64227:99;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66186:249;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64078:84;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77508:88;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77311:25;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;78494:314;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;77458:41;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77343:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64389:118;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38911:103;;;;;;;;;;;;;:::i;:::-;;38236:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63335:95;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77413:38;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64712:182;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;79540:165;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;78913:493;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;77260:42;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64957:142;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39169:220;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;77085:39;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;80364:104;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;63125:91;63170:13;63203:5;63196:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63125:91;:::o;65418:190::-;65491:4;65508:13;65524:12;:10;:12::i;:::-;65508:28;;65547:31;65556:5;65563:7;65572:5;65547:8;:31::i;:::-;65596:4;65589:11;;;65418:190;;;;:::o;77378:28::-;;;;;;;;;;;;;:::o;64227:99::-;64279:7;64306:12;;64299:19;;64227:99;:::o;66186:249::-;66273:4;66290:15;66308:12;:10;:12::i;:::-;66290:30;;66331:37;66347:4;66353:7;66362:5;66331:15;:37::i;:::-;66379:26;66389:4;66395:2;66399:5;66379:9;:26::i;:::-;66423:4;66416:11;;;66186:249;;;;;:::o;64078:84::-;64127:5;64152:2;64145:9;;64078:84;:::o;77508:88::-;;;;;;;;;;;;;:::o;77311:25::-;;;;:::o;78494:314::-;78558:10;:19;78569:7;78558:19;;;;;;;;;;;;;;;;;;;;;78554:49;;;78586:17;;;;;;;;;;;;;;78554:49;78642:10;78618:34;;:3;:11;;;78630:7;78618:20;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:34;;;78614:57;;78661:10;;;;;;;;;;;;;;78614:57;78706:4;78684:10;:19;78695:7;78684:19;;;;;;;;;;;;:26;;;;;;;;;;;;;;;;;;78743:10;78726:28;;78734:7;78726:28;;;;;;;;;;78767:33;78773:10;78785:14;78767:5;:33::i;:::-;78494:314;:::o;77458:41::-;;;;;;;;;;;;;;;;;;;;;;:::o;77343:28::-;;;;;;;;;;;;;:::o;64389:118::-;64454:7;64481:9;:18;64491:7;64481:18;;;;;;;;;;;;;;;;64474:25;;64389:118;;;:::o;38911:103::-;38122:13;:11;:13::i;:::-;38976:30:::1;39003:1;38976:18;:30::i;:::-;38911:103::o:0;38236:87::-;38282:7;38309:6;;;;;;;;;;;38302:13;;38236:87;:::o;63335:95::-;63382:13;63415:7;63408:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63335:95;:::o;77413:38::-;;;;;;;;;;;;;:::o;64712:182::-;64781:4;64798:13;64814:12;:10;:12::i;:::-;64798:28;;64837:27;64847:5;64854:2;64858:5;64837:9;:27::i;:::-;64882:4;64875:11;;;64712:182;;;;:::o;79540:165::-;38122:13;:11;:13::i;:::-;79648:14:::1;79632:13;;:30;;;;;;;;;;;;;;;;;;79686:11;79673:10;:24;;;;79540:165:::0;;:::o;78913:493::-;78993:13;78988:347;79020:8;:15;79012:5;:23;78988:347;;;79061:15;79079:8;79088:5;79079:15;;;;;;;;:::i;:::-;;;;;;;;79061:33;;79115:10;:19;79126:7;79115:19;;;;;;;;;;;;;;;;;;;;;79111:49;;;79143:17;;;;;;;;;;;;;;79111:49;79203:10;79179:34;;:3;:11;;;79191:7;79179:20;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:34;;;79175:57;;79222:10;;;;;;;;;;;;;;79175:57;79271:4;79249:10;:19;79260:7;79249:19;;;;;;;;;;;;:26;;;;;;;;;;;;;;;;;;79312:10;79295:28;;79303:7;79295:28;;;;;;;;;;79046:289;79037:7;;;;;:::i;:::-;;;;78988:347;;;;79347:51;79353:10;79382:8;:15;79365:14;:32;;;;:::i;:::-;79347:5;:51::i;:::-;78913:493;:::o;77260:42::-;;;;;;;;;;;;;;;;;;;;;;:::o;64957:142::-;65037:7;65064:11;:18;65076:5;65064:18;;;;;;;;;;;;;;;:27;65083:7;65064:27;;;;;;;;;;;;;;;;65057:34;;64957:142;;;;:::o;39169:220::-;38122:13;:11;:13::i;:::-;39274:1:::1;39254:22;;:8;:22;;::::0;39250:93:::1;;39328:1;39300:31;;;;;;;;;;;:::i;:::-;;;;;;;;39250:93;39353:28;39372:8;39353:18;:28::i;:::-;39169:220:::0;:::o;77085:39::-;;;:::o;80364:104::-;38122:13;:11;:13::i;:::-;80456:4:::1;80435:8;:18;80444:8;80435:18;;;;;;;;;;;;;;;;:25;;;;;;;;;;;;;;;;;;80364:104:::0;:::o;36245:98::-;36298:7;36325:10;36318:17;;36245:98;:::o;70245:130::-;70330:37;70339:5;70346:7;70355:5;70362:4;70330:8;:37::i;:::-;70245:130;;;:::o;71961:487::-;72061:24;72088:25;72098:5;72105:7;72088:9;:25::i;:::-;72061:52;;72148:17;72128:16;:37;72124:317;;72205:5;72186:16;:24;72182:132;;;72265:7;72274:16;72292:5;72238:60;;;;;;;;;;;;;:::i;:::-;;;;;;;;72182:132;72357:57;72366:5;72373:7;72401:5;72382:16;:24;72408:5;72357:8;:57::i;:::-;72124:317;72050:398;71961:487;;;:::o;66820:308::-;66920:1;66904:18;;:4;:18;;;66900:88;;66973:1;66946:30;;;;;;;;;;;:::i;:::-;;;;;;;;66900:88;67016:1;67002:16;;:2;:16;;;66998:88;;67071:1;67042:32;;;;;;;;;;;:::i;:::-;;;;;;;;66998:88;67096:24;67104:4;67110:2;67114:5;67096:7;:24::i;:::-;66820:308;;;:::o;68940:213::-;69030:1;69011:21;;:7;:21;;;69007:93;;69085:1;69056:32;;;;;;;;;;;:::i;:::-;;;;;;;;69007:93;69110:35;69126:1;69130:7;69139:5;69110:7;:35::i;:::-;68940:213;;:::o;38401:166::-;38472:12;:10;:12::i;:::-;38461:23;;:7;:5;:7::i;:::-;:23;;;38457:103;;38535:12;:10;:12::i;:::-;38508:40;;;;;;;;;;;:::i;:::-;;;;;;;;38457:103;38401:166::o;39549:191::-;39623:16;39642:6;;;;;;;;;;;39623:25;;39668:8;39659:6;;:17;;;;;;;;;;;;;;;;;;39723:8;39692:40;;39713:8;39692:40;;;;;;;;;;;;39612:128;39549:191;:::o;71226:443::-;71356:1;71339:19;;:5;:19;;;71335:91;;71411:1;71382:32;;;;;;;;;;;:::i;:::-;;;;;;;;71335:91;71459:1;71440:21;;:7;:21;;;71436:92;;71513:1;71485:31;;;;;;;;;;;:::i;:::-;;;;;;;;71436:92;71568:5;71538:11;:18;71550:5;71538:18;;;;;;;;;;;;;;;:27;71557:7;71538:27;;;;;;;;;;;;;;;:35;;;;71588:9;71584:78;;;71635:7;71619:31;;71628:5;71619:31;;;71644:5;71619:31;;;;;;:::i;:::-;;;;;;;;71584:78;71226:443;;;;:::o;79846:510::-;79944:8;:14;79953:4;79944:14;;;;;;;;;;;;;;;;;;;;;;;;;79943:15;:32;;;;79963:8;:12;79972:2;79963:12;;;;;;;;;;;;;;;;;;;;;;;;;79962:13;79943:32;79935:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;80039:1;80014:27;;:13;;;;;;;;;;;:27;;;80010:199;;80074:7;:5;:7::i;:::-;80066:15;;:4;:15;;;:32;;;;80091:7;:5;:7::i;:::-;80085:13;;:2;:13;;;80066:32;:55;;;;80108:13;;;;;;;;;;;80102:19;;:2;:19;;;80066:55;:88;;;;80131:23;;;;;;;;;;;80125:29;;:2;:29;;;80066:88;80058:139;;;;;;;;;;;;:::i;:::-;;;;;;;;;80010:199;80260:10;;80251:5;80229:19;80245:2;80229:15;:19::i;:::-;:27;;;;:::i;:::-;:41;;80221:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;80318:30;80332:4;80338:2;80342:5;80318:13;:30::i;:::-;79846:510;;;:::o;67452:1135::-;67558:1;67542:18;;:4;:18;;;67538:552;;67696:5;67680:12;;:21;;;;;;;:::i;:::-;;;;;;;;67538:552;;;67734:19;67756:9;:15;67766:4;67756:15;;;;;;;;;;;;;;;;67734:37;;67804:5;67790:11;:19;67786:117;;;67862:4;67868:11;67881:5;67837:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;67786:117;68058:5;68044:11;:19;68026:9;:15;68036:4;68026:15;;;;;;;;;;;;;;;:37;;;;67719:371;67538:552;68120:1;68106:16;;:2;:16;;;68102:435;;68288:5;68272:12;;:21;;;;;;;;;;;68102:435;;;68505:5;68488:9;:13;68498:2;68488:13;;;;;;;;;;;;;;;;:22;;;;;;;;;;;68102:435;68569:2;68554:25;;68563:4;68554:25;;;68573:5;68554:25;;;;;;:::i;:::-;;;;;;;;67452:1135;;;:::o;7:99:1:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:246::-;368:1;378:113;392:6;389:1;386:13;378:113;;;477:1;472:3;468:11;462:18;458:1;453:3;449:11;442:39;414:2;411:1;407:10;402:15;;378:113;;;525:1;516:6;511:3;507:16;500:27;349:184;287:246;;;:::o;539:102::-;580:6;631:2;627:7;622:2;615:5;611:14;607:28;597:38;;539:102;;;:::o;647:377::-;735:3;763:39;796:5;763:39;:::i;:::-;818:71;882:6;877:3;818:71;:::i;:::-;811:78;;898:65;956:6;951:3;944:4;937:5;933:16;898:65;:::i;:::-;988:29;1010:6;988:29;:::i;:::-;983:3;979:39;972:46;;739:285;647:377;;;;:::o;1030:313::-;1143:4;1181:2;1170:9;1166:18;1158:26;;1230:9;1224:4;1220:20;1216:1;1205:9;1201:17;1194:47;1258:78;1331:4;1322:6;1258:78;:::i;:::-;1250:86;;1030:313;;;;:::o;1349:75::-;1382:6;1415:2;1409:9;1399:19;;1349:75;:::o;1430:117::-;1539:1;1536;1529:12;1553:117;1662:1;1659;1652:12;1676:126;1713:7;1753:42;1746:5;1742:54;1731:65;;1676:126;;;:::o;1808:96::-;1845:7;1874:24;1892:5;1874:24;:::i;:::-;1863:35;;1808:96;;;:::o;1910:122::-;1983:24;2001:5;1983:24;:::i;:::-;1976:5;1973:35;1963:63;;2022:1;2019;2012:12;1963:63;1910:122;:::o;2038:139::-;2084:5;2122:6;2109:20;2100:29;;2138:33;2165:5;2138:33;:::i;:::-;2038:139;;;;:::o;2183:77::-;2220:7;2249:5;2238:16;;2183:77;;;:::o;2266:122::-;2339:24;2357:5;2339:24;:::i;:::-;2332:5;2329:35;2319:63;;2378:1;2375;2368:12;2319:63;2266:122;:::o;2394:139::-;2440:5;2478:6;2465:20;2456:29;;2494:33;2521:5;2494:33;:::i;:::-;2394:139;;;;:::o;2539:474::-;2607:6;2615;2664:2;2652:9;2643:7;2639:23;2635:32;2632:119;;;2670:79;;:::i;:::-;2632:119;2790:1;2815:53;2860:7;2851:6;2840:9;2836:22;2815:53;:::i;:::-;2805:63;;2761:117;2917:2;2943:53;2988:7;2979:6;2968:9;2964:22;2943:53;:::i;:::-;2933:63;;2888:118;2539:474;;;;;:::o;3019:90::-;3053:7;3096:5;3089:13;3082:21;3071:32;;3019:90;;;:::o;3115:109::-;3196:21;3211:5;3196:21;:::i;:::-;3191:3;3184:34;3115:109;;:::o;3230:210::-;3317:4;3355:2;3344:9;3340:18;3332:26;;3368:65;3430:1;3419:9;3415:17;3406:6;3368:65;:::i;:::-;3230:210;;;;:::o;3446:118::-;3533:24;3551:5;3533:24;:::i;:::-;3528:3;3521:37;3446:118;;:::o;3570:222::-;3663:4;3701:2;3690:9;3686:18;3678:26;;3714:71;3782:1;3771:9;3767:17;3758:6;3714:71;:::i;:::-;3570:222;;;;:::o;3798:118::-;3885:24;3903:5;3885:24;:::i;:::-;3880:3;3873:37;3798:118;;:::o;3922:222::-;4015:4;4053:2;4042:9;4038:18;4030:26;;4066:71;4134:1;4123:9;4119:17;4110:6;4066:71;:::i;:::-;3922:222;;;;:::o;4150:619::-;4227:6;4235;4243;4292:2;4280:9;4271:7;4267:23;4263:32;4260:119;;;4298:79;;:::i;:::-;4260:119;4418:1;4443:53;4488:7;4479:6;4468:9;4464:22;4443:53;:::i;:::-;4433:63;;4389:117;4545:2;4571:53;4616:7;4607:6;4596:9;4592:22;4571:53;:::i;:::-;4561:63;;4516:118;4673:2;4699:53;4744:7;4735:6;4724:9;4720:22;4699:53;:::i;:::-;4689:63;;4644:118;4150:619;;;;;:::o;4775:86::-;4810:7;4850:4;4843:5;4839:16;4828:27;;4775:86;;;:::o;4867:112::-;4950:22;4966:5;4950:22;:::i;:::-;4945:3;4938:35;4867:112;;:::o;4985:214::-;5074:4;5112:2;5101:9;5097:18;5089:26;;5125:67;5189:1;5178:9;5174:17;5165:6;5125:67;:::i;:::-;4985:214;;;;:::o;5205:329::-;5264:6;5313:2;5301:9;5292:7;5288:23;5284:32;5281:119;;;5319:79;;:::i;:::-;5281:119;5439:1;5464:53;5509:7;5500:6;5489:9;5485:22;5464:53;:::i;:::-;5454:63;;5410:117;5205:329;;;;:::o;5540:::-;5599:6;5648:2;5636:9;5627:7;5623:23;5619:32;5616:119;;;5654:79;;:::i;:::-;5616:119;5774:1;5799:53;5844:7;5835:6;5824:9;5820:22;5799:53;:::i;:::-;5789:63;;5745:117;5540:329;;;;:::o;5875:117::-;5984:1;5981;5974:12;5998:180;6046:77;6043:1;6036:88;6143:4;6140:1;6133:15;6167:4;6164:1;6157:15;6184:281;6267:27;6289:4;6267:27;:::i;:::-;6259:6;6255:40;6397:6;6385:10;6382:22;6361:18;6349:10;6346:34;6343:62;6340:88;;;6408:18;;:::i;:::-;6340:88;6448:10;6444:2;6437:22;6227:238;6184:281;;:::o;6471:129::-;6505:6;6532:20;;:::i;:::-;6522:30;;6561:33;6589:4;6581:6;6561:33;:::i;:::-;6471:129;;;:::o;6606:311::-;6683:4;6773:18;6765:6;6762:30;6759:56;;;6795:18;;:::i;:::-;6759:56;6845:4;6837:6;6833:17;6825:25;;6905:4;6899;6895:15;6887:23;;6606:311;;;:::o;6923:117::-;7032:1;7029;7022:12;7063:710;7159:5;7184:81;7200:64;7257:6;7200:64;:::i;:::-;7184:81;:::i;:::-;7175:90;;7285:5;7314:6;7307:5;7300:21;7348:4;7341:5;7337:16;7330:23;;7401:4;7393:6;7389:17;7381:6;7377:30;7430:3;7422:6;7419:15;7416:122;;;7449:79;;:::i;:::-;7416:122;7564:6;7547:220;7581:6;7576:3;7573:15;7547:220;;;7656:3;7685:37;7718:3;7706:10;7685:37;:::i;:::-;7680:3;7673:50;7752:4;7747:3;7743:14;7736:21;;7623:144;7607:4;7602:3;7598:14;7591:21;;7547:220;;;7551:21;7165:608;;7063:710;;;;;:::o;7796:370::-;7867:5;7916:3;7909:4;7901:6;7897:17;7893:27;7883:122;;7924:79;;:::i;:::-;7883:122;8041:6;8028:20;8066:94;8156:3;8148:6;8141:4;8133:6;8129:17;8066:94;:::i;:::-;8057:103;;7873:293;7796:370;;;;:::o;8172:539::-;8256:6;8305:2;8293:9;8284:7;8280:23;8276:32;8273:119;;;8311:79;;:::i;:::-;8273:119;8459:1;8448:9;8444:17;8431:31;8489:18;8481:6;8478:30;8475:117;;;8511:79;;:::i;:::-;8475:117;8616:78;8686:7;8677:6;8666:9;8662:22;8616:78;:::i;:::-;8606:88;;8402:302;8172:539;;;;:::o;8717:474::-;8785:6;8793;8842:2;8830:9;8821:7;8817:23;8813:32;8810:119;;;8848:79;;:::i;:::-;8810:119;8968:1;8993:53;9038:7;9029:6;9018:9;9014:22;8993:53;:::i;:::-;8983:63;;8939:117;9095:2;9121:53;9166:7;9157:6;9146:9;9142:22;9121:53;:::i;:::-;9111:63;;9066:118;8717:474;;;;;:::o;9197:180::-;9245:77;9242:1;9235:88;9342:4;9339:1;9332:15;9366:4;9363:1;9356:15;9383:320;9427:6;9464:1;9458:4;9454:12;9444:22;;9511:1;9505:4;9501:12;9532:18;9522:81;;9588:4;9580:6;9576:17;9566:27;;9522:81;9650:2;9642:6;9639:14;9619:18;9616:38;9613:84;;9669:18;;:::i;:::-;9613:84;9434:269;9383:320;;;:::o;9709:143::-;9766:5;9797:6;9791:13;9782:22;;9813:33;9840:5;9813:33;:::i;:::-;9709:143;;;;:::o;9858:351::-;9928:6;9977:2;9965:9;9956:7;9952:23;9948:32;9945:119;;;9983:79;;:::i;:::-;9945:119;10103:1;10128:64;10184:7;10175:6;10164:9;10160:22;10128:64;:::i;:::-;10118:74;;10074:128;9858:351;;;;:::o;10215:180::-;10263:77;10260:1;10253:88;10360:4;10357:1;10350:15;10384:4;10381:1;10374:15;10401:180;10449:77;10446:1;10439:88;10546:4;10543:1;10536:15;10570:4;10567:1;10560:15;10587:233;10626:3;10649:24;10667:5;10649:24;:::i;:::-;10640:33;;10695:66;10688:5;10685:77;10682:103;;10765:18;;:::i;:::-;10682:103;10812:1;10805:5;10801:13;10794:20;;10587:233;;;:::o;10826:410::-;10866:7;10889:20;10907:1;10889:20;:::i;:::-;10884:25;;10923:20;10941:1;10923:20;:::i;:::-;10918:25;;10978:1;10975;10971:9;11000:30;11018:11;11000:30;:::i;:::-;10989:41;;11179:1;11170:7;11166:15;11163:1;11160:22;11140:1;11133:9;11113:83;11090:139;;11209:18;;:::i;:::-;11090:139;10874:362;10826:410;;;;:::o;11242:442::-;11391:4;11429:2;11418:9;11414:18;11406:26;;11442:71;11510:1;11499:9;11495:17;11486:6;11442:71;:::i;:::-;11523:72;11591:2;11580:9;11576:18;11567:6;11523:72;:::i;:::-;11605;11673:2;11662:9;11658:18;11649:6;11605:72;:::i;:::-;11242:442;;;;;;:::o;11690:167::-;11830:19;11826:1;11818:6;11814:14;11807:43;11690:167;:::o;11863:366::-;12005:3;12026:67;12090:2;12085:3;12026:67;:::i;:::-;12019:74;;12102:93;12191:3;12102:93;:::i;:::-;12220:2;12215:3;12211:12;12204:19;;11863:366;;;:::o;12235:419::-;12401:4;12439:2;12428:9;12424:18;12416:26;;12488:9;12482:4;12478:20;12474:1;12463:9;12459:17;12452:47;12516:131;12642:4;12516:131;:::i;:::-;12508:139;;12235:419;;;:::o;12660:225::-;12800:34;12796:1;12788:6;12784:14;12777:58;12869:8;12864:2;12856:6;12852:15;12845:33;12660:225;:::o;12891:366::-;13033:3;13054:67;13118:2;13113:3;13054:67;:::i;:::-;13047:74;;13130:93;13219:3;13130:93;:::i;:::-;13248:2;13243:3;13239:12;13232:19;;12891:366;;;:::o;13263:419::-;13429:4;13467:2;13456:9;13452:18;13444:26;;13516:9;13510:4;13506:20;13502:1;13491:9;13487:17;13480:47;13544:131;13670:4;13544:131;:::i;:::-;13536:139;;13263:419;;;:::o;13688:191::-;13728:3;13747:20;13765:1;13747:20;:::i;:::-;13742:25;;13781:20;13799:1;13781:20;:::i;:::-;13776:25;;13824:1;13821;13817:9;13810:16;;13845:3;13842:1;13839:10;13836:36;;;13852:18;;:::i;:::-;13836:36;13688:191;;;;:::o;13885:172::-;14025:24;14021:1;14013:6;14009:14;14002:48;13885:172;:::o;14063:366::-;14205:3;14226:67;14290:2;14285:3;14226:67;:::i;:::-;14219:74;;14302:93;14391:3;14302:93;:::i;:::-;14420:2;14415:3;14411:12;14404:19;;14063:366;;;:::o;14435:419::-;14601:4;14639:2;14628:9;14624:18;14616:26;;14688:9;14682:4;14678:20;14674:1;14663:9;14659:17;14652:47;14716:131;14842:4;14716:131;:::i;:::-;14708:139;;14435:419;;;:::o

Swarm Source

ipfs://1e0cd1e4a371021c0cefcd7af6bbc80a1f8186d1e341812b2b2213388935ab46

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services