Token

MikaboshiGNC (MGC)

ERC-721

Overview

Max Total Supply

12 MGC

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x79ac8c38e689a6a11470190a14375386768cb113

Filtered by Token Holder

0x6546Bf8d673da23B694fF60EFC45ecC4693F1A58

Balance

3 MGC

0x6546bf8d673da23b694ff60efc45ecc4693f1a58

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

MikaboshiGNC

Compiler Version

v0.8.12+commit.f00d7308

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-12-14
*/

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


// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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 addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

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


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @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 up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (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; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 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.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            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 (rounding == Rounding.Up && 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 down.
     *
     * 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 + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * 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 + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * 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 + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * 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 10, 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 + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

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


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;


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

    /**
     * @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), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @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) {
        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] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        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);
    }
}

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


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @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;
    }
}

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


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


/**
 * @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.
 *
 * By default, the owner account will be the one that deploys the contract. 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;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @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 {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing 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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _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/utils/Address.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

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


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @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 v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @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/interfaces/IERC2981.sol


// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}

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


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;


/**
 * @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);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// File: @openzeppelin/contracts/token/common/ERC2981.sol


// OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol)

pragma solidity ^0.8.0;



/**
 * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
 * fee is specified in basis points by default.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC2981 is IERC2981, ERC165 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;

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

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: invalid receiver");

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: Invalid parameters");

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }
}

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


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


/**
 * @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 caller.
     *
     * 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/IERC721Enumerable.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

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


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @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/token/ERC721/ERC721.sol


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;








/**
 * @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}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => 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 override returns (uint256) {
        require(owner != address(0), "ERC721: address zero is not a valid owner");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _ownerOf(tokenId);
        require(owner != address(0), "ERC721: invalid token ID");
        return owner;
    }

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

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

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

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(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 override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not token owner or approved for all"
        );

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");

        _transfer(from, to, tokenId);
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
        _safeTransfer(from, to, tokenId, data);
    }

    /**
     * @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.
     *
     * `data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - 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,
        bytes memory data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _ownerOf(tokenId) != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * 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 virtual {
        _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);
        require(
            _checkOnERC721Received(address(0), to, tokenId, data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @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 virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId, 1);

        // Check that tokenId was not minted by `_beforeTokenTransfer` hook
        require(!_exists(tokenId), "ERC721: token already minted");

        unchecked {
            // Will not overflow unless all 2**256 token ids are minted to the same owner.
            // Given that tokens are minted one by one, it is impossible in practice that
            // this ever happens. Might change if we allow batch minting.
            // The ERC fails to describe this case.
            _balances[to] += 1;
        }

        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);

        _afterTokenTransfer(address(0), to, tokenId, 1);
    }

    /**
     * @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 virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId, 1);

        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
        owner = ERC721.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        unchecked {
            // Cannot overflow, as that would require more tokens to be burned/transferred
            // out than the owner initially received through minting and transferring in.
            _balances[owner] -= 1;
        }
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);

        _afterTokenTransfer(owner, address(0), tokenId, 1);
    }

    /**
     * @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 virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId, 1);

        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");

        // Clear approvals from the previous owner
        delete _tokenApprovals[tokenId];

        unchecked {
            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
            // `from`'s balance is the number of token held, which is at least one before the current
            // transfer.
            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
            // all 2**256 token ids to be minted, which in practice is impossible.
            _balances[from] -= 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId, 1);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits an {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * 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
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
     * - When `from` is zero, the tokens will be minted for `to`.
     * - When `to` is zero, ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256, /* firstTokenId */
        uint256 batchSize
    ) internal virtual {
        if (batchSize > 1) {
            if (from != address(0)) {
                _balances[from] -= batchSize;
            }
            if (to != address(0)) {
                _balances[to] += batchSize;
            }
        }
    }

    /**
     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
     * - When `from` is zero, the tokens were minted for `to`.
     * - When `to` is zero, ``from``'s tokens were burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual {}
}

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


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol)

pragma solidity ^0.8.0;



/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @dev See {ERC721-_beforeTokenTransfer}.
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, firstTokenId, batchSize);

        if (batchSize > 1) {
            // Will only trigger during construction. Batch transferring (minting) is not available afterwards.
            revert("ERC721Enumerable: consecutive transfers not supported");
        }

        uint256 tokenId = firstTokenId;

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}

// File: contracts/MikaboshiGNC.sol









pragma solidity ^0.8.12;
pragma abicoder v2;

//   __  __ _ _         _               _     _  ____ _   _  ____ 
//  |  \/  (_) | ____ _| |__   ___  ___| |__ (_)/ ___| \ | |/ ___|
//  | |\/| | | |/ / _` | '_ \ / _ \/ __| '_ \| | |  _|  \| | |    
//  | |  | | |   < (_| | |_) | (_) \__ \ | | | | |_| | |\  | |___ 
//  |_|  |_|_|_|\_\__,_|_.__/ \___/|___/_| |_|_|\____|_| \_|\____|
//

contract MikaboshiGNC is ERC721Enumerable, ERC2981, Ownable {
    using SafeMath for uint256;
    using Strings for uint256;

    enum Sale {
        NoSale,
        PublicSale
    }

    uint256 public constant tokenPrice = 77700000000000000; // 0.0777
    uint256 public constant MAX_TOKENS = 3333;
    uint256 public maxTokenPurchase = 10;

    string public baseURI = "";

    Sale public state = Sale.NoSale;

    event MGCMinted(uint256 balance, address owner);

    string public contractURI =
        "https://ipfs.io/ipfs/QmPMav9i8ng3ixtaBkxF9Phi2o6URtLjoZ5TBbo5JRKNZQ";

    address[] private _team = [
        0x7074b3b573c9910f42B46FcAD30cfae6f2a079Ad
    ];

    bytes32 private presaleRoot;

    constructor()
        ERC721("MikaboshiGNC", "MGC")
    {
        _setDefaultRoyalty(address(_team[0]), 1000);
        _transferOwnership(address(_team[0]));
        baseURI = "ipfs://QmZcwJ9oZkxuEsVeHgXMhmbKFHJuLLwKtwKWyJoAg3P8eQ/";
    }

    function _baseURI() internal view virtual override returns (string memory) {
        return baseURI;
    }

    function setBaseURI(string memory _newBaseURI) public onlyOwner {
        baseURI = _newBaseURI;
    }

    function enable() public onlyOwner {
        state = Sale.PublicSale;
    }

    function disable() public onlyOwner {
        state = Sale.NoSale;
    }

    function saleIsActive() public view returns (bool) {
        return state == Sale.PublicSale;
    }

    function exists(uint256 id) public view returns (bool) {
        return _exists(id);
    }

    function mintMGC(uint256[] calldata ids) external payable {
        require(state == Sale.PublicSale, "Public sale not enabled.");
        require(
            ids.length > 0 && ids.length <= maxTokenPurchase,
            "Can only mint one or more tokens at a time."
        );
        require(
            msg.value >= (tokenPrice * ids.length),
            "You need to send proper amount of eth."
        );
        require(
            totalSupply().add(ids.length) <= MAX_TOKENS,
            "Purchase would exceed max supply of tokens."
        );

        for (uint256 i = 0; i < ids.length; i++) {
            require(ids[i] > 0 && ids[i] <= MAX_TOKENS, "invalid id");
            _safeMint(_msgSender(), ids[i]);
        }
        emit MGCMinted(ids.length, _msgSender());

        (bool os, ) = payable(owner()).call{value: address(this).balance}("");
        require(os);
    }

    function tokenURI(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        require(_exists(tokenId), "nonexistent token");
        string memory uri = _baseURI();

        if (bytes(uri).length == 0) {
            return "";
        }
        return string(abi.encodePacked(uri, tokenId.toString(), ".json"));
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC721Enumerable, ERC2981)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }

    function setDefaultRoyalty(address receiver, uint96 feeNumerator)
        public
        onlyOwner
    {
        _setDefaultRoyalty(receiver, feeNumerator);
    }

    function setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) public onlyOwner {
        _setTokenRoyalty(tokenId, receiver, feeNumerator);
    }

    function setContractURI(string calldata _contractURI) public onlyOwner {
        contractURI = _contractURI;
    }

    function setMaxTokenPurchase(uint256 _maxTokenPurchase) public onlyOwner {
        maxTokenPurchase = _maxTokenPurchase;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"balance","type":"uint256"},{"indexed":false,"internalType":"address","name":"owner","type":"address"}],"name":"MGCMinted","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":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_TOKENS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"disable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"enable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTokenPurchase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"mintMGC","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_contractURI","type":"string"}],"name":"setContractURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint96","name":"feeNumerator","type":"uint96"}],"name":"setDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxTokenPurchase","type":"uint256"}],"name":"setMaxTokenPurchase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint96","name":"feeNumerator","type":"uint96"}],"name":"setTokenRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"state","outputs":[{"internalType":"enum MikaboshiGNC.Sale","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

74967:3795:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77886:230;;;;;;;;;;-1:-1:-1;77886:230:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;77886:230:0;;;;;;;;78124:167;;;;;;;;;;-1:-1:-1;78124:167:0;;;;;:::i;:::-;;:::i;:::-;;52644:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;54156:171::-;;;;;;;;;;-1:-1:-1;54156:171:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2317:32:1;;;2299:51;;2287:2;2272:18;54156:171:0;2153:203:1;53674:416:0;;;;;;;;;;-1:-1:-1;53674:416:0;;;;;:::i;:::-;;:::i;75283:36::-;;;;;;;;;;;;;;;;;;;2766:25:1;;;2754:2;2739:18;75283:36:0;2620:177:1;69222:113:0;;;;;;;;;;-1:-1:-1;69310:10:0;:17;69222:113;;54856:335;;;;;;;;;;-1:-1:-1;54856:335:0;;;;;:::i;:::-;;:::i;40815:442::-;;;;;;;;;;-1:-1:-1;40815:442:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;3580:32:1;;;3562:51;;3644:2;3629:18;;3622:34;;;;3535:18;40815:442:0;3388:274:1;76271:74:0;;;;;;;;;;;;;:::i;68890:256::-;;;;;;;;;;-1:-1:-1;68890:256:0;;;;;:::i;:::-;;:::i;76562:912::-;;;;;;:::i;:::-;;:::i;55262:185::-;;;;;;;;;;-1:-1:-1;55262:185:0;;;;;:::i;:::-;;:::i;76462:92::-;;;;;;;;;;-1:-1:-1;76462:92:0;;;;;:::i;:::-;;:::i;69412:233::-;;;;;;;;;;-1:-1:-1;69412:233:0;;;;;:::i;:::-;;:::i;76074:104::-;;;;;;;;;;-1:-1:-1;76074:104:0;;;;;:::i;:::-;;:::i;78299:200::-;;;;;;;;;;-1:-1:-1;78299:200:0;;;;;:::i;:::-;;:::i;52354:223::-;;;;;;;;;;-1:-1:-1;52354:223:0;;;;;:::i;:::-;;:::i;75328:26::-;;;;;;;;;;;;;:::i;52085:207::-;;;;;;;;;;-1:-1:-1;52085:207:0;;;;;:::i;:::-;;:::i;25016:103::-;;;;;;;;;;;;;:::i;75164:54::-;;;;;;;;;;;;75201:17;75164:54;;24368:87;;;;;;;;;;-1:-1:-1;24441:6:0;;-1:-1:-1;;;;;24441:6:0;24368:87;;78507:116;;;;;;;;;;-1:-1:-1;78507:116:0;;;;;:::i;:::-;;:::i;52813:104::-;;;;;;;;;;;;;:::i;54399:155::-;;;;;;;;;;-1:-1:-1;54399:155:0;;;;;:::i;:::-;;:::i;76186:77::-;;;;;;;;;;;;;:::i;55518:322::-;;;;;;;;;;-1:-1:-1;55518:322:0;;;;;:::i;:::-;;:::i;78631:128::-;;;;;;;;;;-1:-1:-1;78631:128:0;;;;;:::i;:::-;;:::i;75363:31::-;;;;;;;;;;-1:-1:-1;75363:31:0;;;;;;;;;;;;;;;:::i;77482:396::-;;;;;;;;;;-1:-1:-1;77482:396:0;;;;;:::i;:::-;;:::i;75459:106::-;;;;;;;;;;;;;:::i;54625:164::-;;;;;;;;;;-1:-1:-1;54625:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;54746:25:0;;;54722:4;54746:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;54625:164;76353:101;;;;;;;;;;;;;:::i;25274:201::-;;;;;;;;;;-1:-1:-1;25274:201:0;;;;;:::i;:::-;;:::i;75235:41::-;;;;;;;;;;;;75272:4;75235:41;;77886:230;78043:4;78072:36;78096:11;78072:23;:36::i;:::-;78065:43;77886:230;-1:-1:-1;;77886:230:0:o;78124:167::-;24254:13;:11;:13::i;:::-;78241:42:::1;78260:8;78270:12;78241:18;:42::i;:::-;78124:167:::0;;:::o;52644:100::-;52698:13;52731:5;52724:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52644:100;:::o;54156:171::-;54232:7;54252:23;54267:7;54252:14;:23::i;:::-;-1:-1:-1;54295:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;54295:24:0;;54156:171::o;53674:416::-;53755:13;53771:23;53786:7;53771:14;:23::i;:::-;53755:39;;53819:5;-1:-1:-1;;;;;53813:11:0;:2;-1:-1:-1;;;;;53813:11:0;;;53805:57;;;;-1:-1:-1;;;53805:57:0;;8981:2:1;53805:57:0;;;8963:21:1;9020:2;9000:18;;;8993:30;9059:34;9039:18;;;9032:62;-1:-1:-1;;;9110:18:1;;;9103:31;9151:19;;53805:57:0;;;;;;;;;22999:10;-1:-1:-1;;;;;53897:21:0;;;;:62;;-1:-1:-1;53922:37:0;53939:5;22999:10;54625:164;:::i;53922:37::-;53875:173;;;;-1:-1:-1;;;53875:173:0;;9383:2:1;53875:173:0;;;9365:21:1;9422:2;9402:18;;;9395:30;9461:34;9441:18;;;9434:62;9532:31;9512:18;;;9505:59;9581:19;;53875:173:0;9181:425:1;53875:173:0;54061:21;54070:2;54074:7;54061:8;:21::i;:::-;53744:346;53674:416;;:::o;54856:335::-;55051:41;22999:10;55084:7;55051:18;:41::i;:::-;55043:99;;;;-1:-1:-1;;;55043:99:0;;;;;;;:::i;:::-;55155:28;55165:4;55171:2;55175:7;55155:9;:28::i;40815:442::-;40912:7;40970:27;;;:17;:27;;;;;;;;40941:56;;;;;;;;;-1:-1:-1;;;;;40941:56:0;;;;;-1:-1:-1;;;40941:56:0;;;-1:-1:-1;;;;;40941:56:0;;;;;;;;40912:7;;41010:92;;-1:-1:-1;41061:29:0;;;;;;;;;41071:19;41061:29;-1:-1:-1;;;;;41061:29:0;;;;-1:-1:-1;;;41061:29:0;;-1:-1:-1;;;;;41061:29:0;;;;;41010:92;41152:23;;;;41114:21;;41623:5;;41139:36;;-1:-1:-1;;;;;41139:36:0;:10;:36;:::i;:::-;41138:58;;;;:::i;:::-;41217:16;;;;;-1:-1:-1;40815:442:0;;-1:-1:-1;;;;40815:442:0:o;76271:74::-;24254:13;:11;:13::i;:::-;76318:5:::1;:19:::0;;76326:11:::1;::::0;76318:5;-1:-1:-1;;76318:19:0::1;::::0;76326:11;76318:19:::1;;;;;;76271:74::o:0;68890:256::-;68987:7;69023:23;69040:5;69023:16;:23::i;:::-;69015:5;:31;69007:87;;;;-1:-1:-1;;;69007:87:0;;10886:2:1;69007:87:0;;;10868:21:1;10925:2;10905:18;;;10898:30;10964:34;10944:18;;;10937:62;-1:-1:-1;;;11015:18:1;;;11008:41;11066:19;;69007:87:0;10684:407:1;69007:87:0;-1:-1:-1;;;;;;69112:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;68890:256::o;76562:912::-;76648:15;76639:5;;;;;:24;;;;;;;:::i;:::-;;76631:61;;;;-1:-1:-1;;;76631:61:0;;11298:2:1;76631:61:0;;;11280:21:1;11337:2;11317:18;;;11310:30;11376:26;11356:18;;;11349:54;11420:18;;76631:61:0;11096:348:1;76631:61:0;76725:14;;;;;:48;;-1:-1:-1;76757:16:0;;76743:30;;;76725:48;76703:141;;;;-1:-1:-1;;;76703:141:0;;11651:2:1;76703:141:0;;;11633:21:1;11690:2;11670:18;;;11663:30;11729:34;11709:18;;;11702:62;-1:-1:-1;;;11780:18:1;;;11773:41;11831:19;;76703:141:0;11449:407:1;76703:141:0;76891:23;76904:3;75201:17;76891:23;:::i;:::-;76877:9;:38;;76855:126;;;;-1:-1:-1;;;76855:126:0;;12063:2:1;76855:126:0;;;12045:21:1;12102:2;12082:18;;;12075:30;12141:34;12121:18;;;12114:62;-1:-1:-1;;;12192:18:1;;;12185:36;12238:19;;76855:126:0;11861:402:1;76855:126:0;75272:4;77014:29;77032:3;77014:13;69310:10;:17;;69222:113;77014:13;:17;;:29::i;:::-;:43;;76992:136;;;;-1:-1:-1;;;76992:136:0;;12470:2:1;76992:136:0;;;12452:21:1;12509:2;12489:18;;;12482:30;12548:34;12528:18;;;12521:62;-1:-1:-1;;;12599:18:1;;;12592:41;12650:19;;76992:136:0;12268:407:1;76992:136:0;77146:9;77141:171;77161:14;;;77141:171;;;77214:1;77205:3;;77209:1;77205:6;;;;;;;:::i;:::-;;;;;;;:10;:34;;;;;75272:4;77219:3;;77223:1;77219:6;;;;;;;:::i;:::-;;;;;;;:20;;77205:34;77197:57;;;;-1:-1:-1;;;77197:57:0;;13014:2:1;77197:57:0;;;12996:21:1;13053:2;13033:18;;;13026:30;-1:-1:-1;;;13072:18:1;;;13065:40;13122:18;;77197:57:0;12812:334:1;77197:57:0;77269:31;22999:10;77293:3;;77297:1;77293:6;;;;;;;:::i;:::-;;;;;;;77269:9;:31::i;:::-;77177:3;;;;:::i;:::-;;;;77141:171;;;-1:-1:-1;77327:35:0;;;13465:25:1;;;22999:10:0;13521:2:1;13506:18;;13499:60;77327:35:0;;;;;;;;;;;;;77376:7;77397;24441:6;;-1:-1:-1;;;;;24441:6:0;;24368:87;77397:7;-1:-1:-1;;;;;77389:21:0;77418;77389:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77375:69;;;77463:2;77455:11;;;;;55262:185;55400:39;55417:4;55423:2;55427:7;55400:39;;;;;;;;;;;;:16;:39::i;76462:92::-;76511:4;57241:16;;;:7;:16;;;;;;-1:-1:-1;;;;;57241:16:0;57667:31;;76535:11;57578:128;69412:233;69487:7;69523:30;69310:10;:17;;69222:113;69523:30;69515:5;:38;69507:95;;;;-1:-1:-1;;;69507:95:0;;13982:2:1;69507:95:0;;;13964:21:1;14021:2;14001:18;;;13994:30;14060:34;14040:18;;;14033:62;-1:-1:-1;;;14111:18:1;;;14104:42;14163:19;;69507:95:0;13780:408:1;69507:95:0;69620:10;69631:5;69620:17;;;;;;;;:::i;:::-;;;;;;;;;69613:24;;69412:233;;;:::o;76074:104::-;24254:13;:11;:13::i;:::-;76149:21;;::::1;::::0;:7:::1;::::0;:21:::1;::::0;::::1;::::0;::::1;:::i;78299:200::-:0;24254:13;:11;:13::i;:::-;78442:49:::1;78459:7;78468:8;78478:12;78442:16;:49::i;52354:223::-:0;52426:7;57241:16;;;:7;:16;;;;;;-1:-1:-1;;;;;57241:16:0;;52490:56;;;;-1:-1:-1;;;52490:56:0;;14395:2:1;52490:56:0;;;14377:21:1;14434:2;14414:18;;;14407:30;-1:-1:-1;;;14453:18:1;;;14446:54;14517:18;;52490:56:0;14193:348:1;75328:26:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;52085:207::-;52157:7;-1:-1:-1;;;;;52185:19:0;;52177:73;;;;-1:-1:-1;;;52177:73:0;;14748:2:1;52177:73:0;;;14730:21:1;14787:2;14767:18;;;14760:30;14826:34;14806:18;;;14799:62;-1:-1:-1;;;14877:18:1;;;14870:39;14926:19;;52177:73:0;14546:405:1;52177:73:0;-1:-1:-1;;;;;;52268:16:0;;;;;:9;:16;;;;;;;52085:207::o;25016:103::-;24254:13;:11;:13::i;:::-;25081:30:::1;25108:1;25081:18;:30::i;:::-;25016:103::o:0;78507:116::-;24254:13;:11;:13::i;:::-;78589:26:::1;:11;78603:12:::0;;78589:26:::1;:::i;52813:104::-:0;52869:13;52902:7;52895:14;;;;;:::i;54399:155::-;54494:52;22999:10;54527:8;54537;54494:18;:52::i;76186:77::-;24254:13;:11;:13::i;:::-;76232:5:::1;:23:::0;;76240:15:::1;::::0;76232:5;-1:-1:-1;;76232:23:0::1;76240:15:::0;;76232:23:::1;::::0;55518:322;55692:41;22999:10;55725:7;55692:18;:41::i;:::-;55684:99;;;;-1:-1:-1;;;55684:99:0;;;;;;;:::i;:::-;55794:38;55808:4;55814:2;55818:7;55827:4;55794:13;:38::i;:::-;55518:322;;;;:::o;78631:128::-;24254:13;:11;:13::i;:::-;78715:16:::1;:36:::0;78631:128::o;77482:396::-;57643:4;57241:16;;;:7;:16;;;;;;77600:13;;-1:-1:-1;;;;;57241:16:0;77631:46;;;;-1:-1:-1;;;77631:46:0;;15158:2:1;77631:46:0;;;15140:21:1;15197:2;15177:18;;;15170:30;-1:-1:-1;;;15216:18:1;;;15209:47;15273:18;;77631:46:0;14956:341:1;77631:46:0;77688:17;77708:10;:8;:10::i;:::-;77688:30;;77741:3;77735:17;77756:1;77735:22;77731:64;;;-1:-1:-1;;77774:9:0;;;;;;;;;-1:-1:-1;77774:9:0;;;77482:396;-1:-1:-1;77482:396:0:o;77731:64::-;77836:3;77841:18;:7;:16;:18::i;:::-;77819:50;;;;;;;;;:::i;:::-;;;;;;;;;;;;;77805:65;;;77482:396;;;:::o;75459:106::-;;;;;;;:::i;76353:101::-;76398:4;76431:15;76422:5;;;;;:24;;;;;;;:::i;:::-;;76415:31;;76353:101;:::o;25274:201::-;24254:13;:11;:13::i;:::-;-1:-1:-1;;;;;25363:22:0;::::1;25355:73;;;::::0;-1:-1:-1;;;25355:73:0;;16146:2:1;25355:73:0::1;::::0;::::1;16128:21:1::0;16185:2;16165:18;;;16158:30;16224:34;16204:18;;;16197:62;-1:-1:-1;;;16275:18:1;;;16268:36;16321:19;;25355:73:0::1;15944:402:1::0;25355:73:0::1;25439:28;25458:8;25439:18;:28::i;:::-;25274:201:::0;:::o;40545:215::-;40647:4;-1:-1:-1;;;;;;40671:41:0;;-1:-1:-1;;;40671:41:0;;:81;;;40716:36;40740:11;40716:23;:36::i;24533:132::-;24441:6;;-1:-1:-1;;;;;24441:6:0;22999:10;24597:23;24589:68;;;;-1:-1:-1;;;24589:68:0;;16553:2:1;24589:68:0;;;16535:21:1;;;16572:18;;;16565:30;16631:34;16611:18;;;16604:62;16683:18;;24589:68:0;16351:356:1;41907:332:0;41623:5;-1:-1:-1;;;;;42010:33:0;;;;42002:88;;;;-1:-1:-1;;;42002:88:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;42109:22:0;;42101:60;;;;-1:-1:-1;;;42101:60:0;;17325:2:1;42101:60:0;;;17307:21:1;17364:2;17344:18;;;17337:30;17403:27;17383:18;;;17376:55;17448:18;;42101:60:0;17123:349:1;42101:60:0;42196:35;;;;;;;;;-1:-1:-1;;;;;42196:35:0;;;;;;-1:-1:-1;;;;;42196:35:0;;;;;;;;;;-1:-1:-1;;;42174:57:0;;;;:19;:57;41907:332::o;63975:135::-;57643:4;57241:16;;;:7;:16;;;;;;-1:-1:-1;;;;;57241:16:0;64049:53;;;;-1:-1:-1;;;64049:53:0;;14395:2:1;64049:53:0;;;14377:21:1;14434:2;14414:18;;;14407:30;-1:-1:-1;;;14453:18:1;;;14446:54;14517:18;;64049:53:0;14193:348:1;63254:174:0;63329:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;63329:29:0;-1:-1:-1;;;;;63329:29:0;;;;;;;;:24;;63383:23;63329:24;63383:14;:23::i;:::-;-1:-1:-1;;;;;63374:46:0;;;;;;;;;;;63254:174;;:::o;57873:264::-;57966:4;57983:13;57999:23;58014:7;57999:14;:23::i;:::-;57983:39;;58052:5;-1:-1:-1;;;;;58041:16:0;:7;-1:-1:-1;;;;;58041:16:0;;:52;;;-1:-1:-1;;;;;;54746:25:0;;;54722:4;54746:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;58061:32;58041:87;;;;58121:7;-1:-1:-1;;;;;58097:31:0;:20;58109:7;58097:11;:20::i;:::-;-1:-1:-1;;;;;58097:31:0;;58041:87;58033:96;57873:264;-1:-1:-1;;;;57873:264:0:o;61872:1263::-;62031:4;-1:-1:-1;;;;;62004:31:0;:23;62019:7;62004:14;:23::i;:::-;-1:-1:-1;;;;;62004:31:0;;61996:81;;;;-1:-1:-1;;;61996:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;62096:16:0;;62088:65;;;;-1:-1:-1;;;62088:65:0;;18085:2:1;62088:65:0;;;18067:21:1;18124:2;18104:18;;;18097:30;18163:34;18143:18;;;18136:62;-1:-1:-1;;;18214:18:1;;;18207:34;18258:19;;62088:65:0;17883:400:1;62088:65:0;62166:42;62187:4;62193:2;62197:7;62206:1;62166:20;:42::i;:::-;62338:4;-1:-1:-1;;;;;62311:31:0;:23;62326:7;62311:14;:23::i;:::-;-1:-1:-1;;;;;62311:31:0;;62303:81;;;;-1:-1:-1;;;62303:81:0;;;;;;;:::i;:::-;62456:24;;;;:15;:24;;;;;;;;62449:31;;-1:-1:-1;;;;;;62449:31:0;;;;;;-1:-1:-1;;;;;62932:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;62932:20:0;;;62967:13;;;;;;;;;:18;;62449:31;62967:18;;;63007:16;;;:7;:16;;;;;;:21;;;;;;;;;;63046:27;;62472:7;;63046:27;;;53744:346;53674:416;;:::o;2876:98::-;2934:7;2961:5;2965:1;2961;:5;:::i;:::-;2954:12;2876:98;-1:-1:-1;;;2876:98:0:o;58479:110::-;58555:26;58565:2;58569:7;58555:26;;;;;;;;;;;;:9;:26::i;42690:390::-;41623:5;-1:-1:-1;;;;;42842:33:0;;;;42834:88;;;;-1:-1:-1;;;42834:88:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;42941:22:0;;42933:62;;;;-1:-1:-1;;;42933:62:0;;18623:2:1;42933:62:0;;;18605:21:1;18662:2;18642:18;;;18635:30;18701:29;18681:18;;;18674:57;18748:18;;42933:62:0;18421:351:1;42933:62:0;43037:35;;;;;;;;-1:-1:-1;;;;;43037:35:0;;;;;-1:-1:-1;;;;;43037:35:0;;;;;;;;;;-1:-1:-1;43008:26:0;;;:17;:26;;;;;;:64;;;;;;;-1:-1:-1;;;43008:64:0;;;;;;42690:390::o;25635:191::-;25728:6;;;-1:-1:-1;;;;;25745:17:0;;;-1:-1:-1;;;;;;25745:17:0;;;;;;;25778:40;;25728:6;;;25745:17;25728:6;;25778:40;;25709:16;;25778:40;25698:128;25635:191;:::o;63571:315::-;63726:8;-1:-1:-1;;;;;63717:17:0;:5;-1:-1:-1;;;;;63717:17:0;;;63709:55;;;;-1:-1:-1;;;63709:55:0;;18979:2:1;63709:55:0;;;18961:21:1;19018:2;18998:18;;;18991:30;19057:27;19037:18;;;19030:55;19102:18;;63709:55:0;18777:349:1;63709:55:0;-1:-1:-1;;;;;63775:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;63775:46:0;;;;;;;;;;63837:41;;540::1;;;63837::0;;513:18:1;63837:41:0;;;;;;;63571:315;;;:::o;56721:313::-;56877:28;56887:4;56893:2;56897:7;56877:9;:28::i;:::-;56924:47;56947:4;56953:2;56957:7;56966:4;56924:22;:47::i;:::-;56916:110;;;;-1:-1:-1;;;56916:110:0;;;;;;;:::i;75958:108::-;76018:13;76051:7;76044:14;;;;;:::i;20346:716::-;20402:13;20453:14;20470:17;20481:5;20470:10;:17::i;:::-;20490:1;20470:21;20453:38;;20506:20;20540:6;20529:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20529:18:0;-1:-1:-1;20506:41:0;-1:-1:-1;20671:28:0;;;20687:2;20671:28;20728:288;-1:-1:-1;;20760:5:0;-1:-1:-1;;;20897:2:0;20886:14;;20881:30;20760:5;20868:44;20958:2;20949:11;;;-1:-1:-1;20983:10:0;20979:21;;20995:5;;20979:21;20728:288;;;-1:-1:-1;21037:6:0;20346:716;-1:-1:-1;;;20346:716:0:o;68582:224::-;68684:4;-1:-1:-1;;;;;;68708:50:0;;-1:-1:-1;;;68708:50:0;;:90;;;68762:36;68786:11;68762:23;:36::i;69719:915::-;69896:61;69923:4;69929:2;69933:12;69947:9;69896:26;:61::i;:::-;69986:1;69974:9;:13;69970:222;;;70117:63;;-1:-1:-1;;;70117:63:0;;19752:2:1;70117:63:0;;;19734:21:1;19791:2;19771:18;;;19764:30;19830:34;19810:18;;;19803:62;-1:-1:-1;;;19881:18:1;;;19874:51;19942:19;;70117:63:0;19550:417:1;69970:222:0;70222:12;-1:-1:-1;;;;;70251:18:0;;70247:187;;70286:40;70318:7;71461:10;:17;;71434:24;;;;:15;:24;;;;;:44;;;71489:24;;;;;;;;;;;;71357:164;70286:40;70247:187;;;70356:2;-1:-1:-1;;;;;70348:10:0;:4;-1:-1:-1;;;;;70348:10:0;;70344:90;;70375:47;70408:4;70414:7;70375:32;:47::i;:::-;-1:-1:-1;;;;;70448:16:0;;70444:183;;70481:45;70518:7;70481:36;:45::i;:::-;70444:183;;;70554:4;-1:-1:-1;;;;;70548:10:0;:2;-1:-1:-1;;;;;70548:10:0;;70544:83;;70575:40;70603:2;70607:7;70575:27;:40::i;:::-;69885:749;69719:915;;;;:::o;58816:319::-;58945:18;58951:2;58955:7;58945:5;:18::i;:::-;58996:53;59027:1;59031:2;59035:7;59044:4;58996:22;:53::i;:::-;58974:153;;;;-1:-1:-1;;;58974:153:0;;;;;;;:::i;64674:853::-;64828:4;-1:-1:-1;;;;;64849:13:0;;27361:19;:23;64845:675;;64885:71;;-1:-1:-1;;;64885:71:0;;-1:-1:-1;;;;;64885:36:0;;;;;:71;;22999:10;;64936:4;;64942:7;;64951:4;;64885:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64885:71:0;;;;;;;;-1:-1:-1;;64885:71:0;;;;;;;;;;;;:::i;:::-;;;64881:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65126:13:0;;65122:328;;65169:60;;-1:-1:-1;;;65169:60:0;;;;;;;:::i;65122:328::-;65400:6;65394:13;65385:6;65381:2;65377:15;65370:38;64881:584;-1:-1:-1;;;;;;65007:51:0;-1:-1:-1;;;65007:51:0;;-1:-1:-1;65000:58:0;;64845:675;-1:-1:-1;65504:4:0;64674:853;;;;;;:::o;17212:922::-;17265:7;;-1:-1:-1;;;17343:15:0;;17339:102;;-1:-1:-1;;;17379:15:0;;;-1:-1:-1;17423:2:0;17413:12;17339:102;17468:6;17459:5;:15;17455:102;;17504:6;17495:15;;;-1:-1:-1;17539:2:0;17529:12;17455:102;17584:6;17575:5;:15;17571:102;;17620:6;17611:15;;;-1:-1:-1;17655:2:0;17645:12;17571:102;17700:5;17691;:14;17687:99;;17735:5;17726:14;;;-1:-1:-1;17769:1:0;17759:11;17687:99;17813:5;17804;:14;17800:99;;17848:5;17839:14;;;-1:-1:-1;17882:1:0;17872:11;17800:99;17926:5;17917;:14;17913:99;;17961:5;17952:14;;;-1:-1:-1;17995:1:0;17985:11;17913:99;18039:5;18030;:14;18026:66;;18075:1;18065:11;18120:6;17212:922;-1:-1:-1;;17212:922:0:o;51716:305::-;51818:4;-1:-1:-1;;;;;;51855:40:0;;-1:-1:-1;;;51855:40:0;;:105;;-1:-1:-1;;;;;;;51912:48:0;;-1:-1:-1;;;51912:48:0;51855:105;:158;;;-1:-1:-1;;;;;;;;;;39104:40:0;;;51977:36;38995:157;66259:410;66449:1;66437:9;:13;66433:229;;;-1:-1:-1;;;;;66471:18:0;;;66467:87;;-1:-1:-1;;;;;66510:15:0;;;;;;:9;:15;;;;;:28;;66529:9;;66510:15;:28;;66529:9;;66510:28;:::i;:::-;;;;-1:-1:-1;;66467:87:0;-1:-1:-1;;;;;66572:16:0;;;66568:83;;-1:-1:-1;;;;;66609:13:0;;;;;;:9;:13;;;;;:26;;66626:9;;66609:13;:26;;66626:9;;66609:26;:::i;:::-;;;;-1:-1:-1;;66259:410:0;;;;:::o;72148:988::-;72414:22;72464:1;72439:22;72456:4;72439:16;:22::i;:::-;:26;;;;:::i;:::-;72476:18;72497:26;;;:17;:26;;;;;;72414:51;;-1:-1:-1;72630:28:0;;;72626:328;;-1:-1:-1;;;;;72697:18:0;;72675:19;72697:18;;;:12;:18;;;;;;;;:34;;;;;;;;;72748:30;;;;;;:44;;;72865:30;;:17;:30;;;;;:43;;;72626:328;-1:-1:-1;73050:26:0;;;;:17;:26;;;;;;;;73043:33;;;-1:-1:-1;;;;;73094:18:0;;;;;:12;:18;;;;;:34;;;;;;;73087:41;72148:988::o;73431:1079::-;73709:10;:17;73684:22;;73709:21;;73729:1;;73709:21;:::i;:::-;73741:18;73762:24;;;:15;:24;;;;;;74135:10;:26;;73684:46;;-1:-1:-1;73762:24:0;;73684:46;;74135:26;;;;;;:::i;:::-;;;;;;;;;74113:48;;74199:11;74174:10;74185;74174:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;74279:28;;;:15;:28;;;;;;;:41;;;74451:24;;;;;74444:31;74486:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;73502:1008;;;73431:1079;:::o;70935:221::-;71020:14;71037:20;71054:2;71037:16;:20::i;:::-;-1:-1:-1;;;;;71068:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;71113:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;70935:221:0:o;59471:942::-;-1:-1:-1;;;;;59551:16:0;;59543:61;;;;-1:-1:-1;;;59543:61:0;;21184:2:1;59543:61:0;;;21166:21:1;;;21203:18;;;21196:30;21262:34;21242:18;;;21235:62;21314:18;;59543:61:0;20982:356:1;59543:61:0;57643:4;57241:16;;;:7;:16;;;;;;-1:-1:-1;;;;;57241:16:0;57667:31;59615:58;;;;-1:-1:-1;;;59615:58:0;;21545:2:1;59615:58:0;;;21527:21:1;21584:2;21564:18;;;21557:30;21623;21603:18;;;21596:58;21671:18;;59615:58:0;21343:352:1;59615:58:0;59686:48;59715:1;59719:2;59723:7;59732:1;59686:20;:48::i;:::-;57643:4;57241:16;;;:7;:16;;;;;;-1:-1:-1;;;;;57241:16:0;57667:31;59824:58;;;;-1:-1:-1;;;59824:58:0;;21545:2:1;59824:58:0;;;21527:21:1;21584:2;21564:18;;;21557:30;21623;21603:18;;;21596:58;21671:18;;59824:58:0;21343:352:1;59824:58:0;-1:-1:-1;;;;;60231:13:0;;;;;;:9;:13;;;;;;;;:18;;60248:1;60231:18;;;60273:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;60273:21:0;;;;;60312:33;60281:7;;60231:13;;60312:33;;60231:13;;60312:33;78124:167;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:173::-;660:20;;-1:-1:-1;;;;;709:31:1;;699:42;;689:70;;755:1;752;745:12;689:70;592:173;;;:::o;770:179::-;837:20;;-1:-1:-1;;;;;886:38:1;;876:49;;866:77;;939:1;936;929:12;954:258;1021:6;1029;1082:2;1070:9;1061:7;1057:23;1053:32;1050:52;;;1098:1;1095;1088:12;1050:52;1121:29;1140:9;1121:29;:::i;:::-;1111:39;;1169:37;1202:2;1191:9;1187:18;1169:37;:::i;:::-;1159:47;;954:258;;;;;:::o;1217:::-;1289:1;1299:113;1313:6;1310:1;1307:13;1299:113;;;1389:11;;;1383:18;1370:11;;;1363:39;1335:2;1328:10;1299:113;;;1430:6;1427:1;1424:13;1421:48;;;-1:-1:-1;;1465:1:1;1447:16;;1440:27;1217:258::o;1480:::-;1522:3;1560:5;1554:12;1587:6;1582:3;1575:19;1603:63;1659:6;1652:4;1647:3;1643:14;1636:4;1629:5;1625:16;1603:63;:::i;:::-;1720:2;1699:15;-1:-1:-1;;1695:29:1;1686:39;;;;1727:4;1682:50;;1480:258;-1:-1:-1;;1480:258:1:o;1743:220::-;1892:2;1881:9;1874:21;1855:4;1912:45;1953:2;1942:9;1938:18;1930:6;1912:45;:::i;1968:180::-;2027:6;2080:2;2068:9;2059:7;2055:23;2051:32;2048:52;;;2096:1;2093;2086:12;2048:52;-1:-1:-1;2119:23:1;;1968:180;-1:-1:-1;1968:180:1:o;2361:254::-;2429:6;2437;2490:2;2478:9;2469:7;2465:23;2461:32;2458:52;;;2506:1;2503;2496:12;2458:52;2529:29;2548:9;2529:29;:::i;:::-;2519:39;2605:2;2590:18;;;;2577:32;;-1:-1:-1;;;2361:254:1:o;2802:328::-;2879:6;2887;2895;2948:2;2936:9;2927:7;2923:23;2919:32;2916:52;;;2964:1;2961;2954:12;2916:52;2987:29;3006:9;2987:29;:::i;:::-;2977:39;;3035:38;3069:2;3058:9;3054:18;3035:38;:::i;:::-;3025:48;;3120:2;3109:9;3105:18;3092:32;3082:42;;2802:328;;;;;:::o;3135:248::-;3203:6;3211;3264:2;3252:9;3243:7;3239:23;3235:32;3232:52;;;3280:1;3277;3270:12;3232:52;-1:-1:-1;;3303:23:1;;;3373:2;3358:18;;;3345:32;;-1:-1:-1;3135:248:1:o;3667:615::-;3753:6;3761;3814:2;3802:9;3793:7;3789:23;3785:32;3782:52;;;3830:1;3827;3820:12;3782:52;3870:9;3857:23;3899:18;3940:2;3932:6;3929:14;3926:34;;;3956:1;3953;3946:12;3926:34;3994:6;3983:9;3979:22;3969:32;;4039:7;4032:4;4028:2;4024:13;4020:27;4010:55;;4061:1;4058;4051:12;4010:55;4101:2;4088:16;4127:2;4119:6;4116:14;4113:34;;;4143:1;4140;4133:12;4113:34;4196:7;4191:2;4181:6;4178:1;4174:14;4170:2;4166:23;4162:32;4159:45;4156:65;;;4217:1;4214;4207:12;4156:65;4248:2;4240:11;;;;;4270:6;;-1:-1:-1;3667:615:1;;-1:-1:-1;;;;3667:615:1:o;4287:127::-;4348:10;4343:3;4339:20;4336:1;4329:31;4379:4;4376:1;4369:15;4403:4;4400:1;4393:15;4419:632;4484:5;4514:18;4555:2;4547:6;4544:14;4541:40;;;4561:18;;:::i;:::-;4636:2;4630:9;4604:2;4690:15;;-1:-1:-1;;4686:24:1;;;4712:2;4682:33;4678:42;4666:55;;;4736:18;;;4756:22;;;4733:46;4730:72;;;4782:18;;:::i;:::-;4822:10;4818:2;4811:22;4851:6;4842:15;;4881:6;4873;4866:22;4921:3;4912:6;4907:3;4903:16;4900:25;4897:45;;;4938:1;4935;4928:12;4897:45;4988:6;4983:3;4976:4;4968:6;4964:17;4951:44;5043:1;5036:4;5027:6;5019;5015:19;5011:30;5004:41;;;;4419:632;;;;;:::o;5056:451::-;5125:6;5178:2;5166:9;5157:7;5153:23;5149:32;5146:52;;;5194:1;5191;5184:12;5146:52;5234:9;5221:23;5267:18;5259:6;5256:30;5253:50;;;5299:1;5296;5289:12;5253:50;5322:22;;5375:4;5367:13;;5363:27;-1:-1:-1;5353:55:1;;5404:1;5401;5394:12;5353:55;5427:74;5493:7;5488:2;5475:16;5470:2;5466;5462:11;5427:74;:::i;5512:326::-;5588:6;5596;5604;5657:2;5645:9;5636:7;5632:23;5628:32;5625:52;;;5673:1;5670;5663:12;5625:52;5709:9;5696:23;5686:33;;5738:38;5772:2;5761:9;5757:18;5738:38;:::i;:::-;5728:48;;5795:37;5828:2;5817:9;5813:18;5795:37;:::i;:::-;5785:47;;5512:326;;;;;:::o;5843:186::-;5902:6;5955:2;5943:9;5934:7;5930:23;5926:32;5923:52;;;5971:1;5968;5961:12;5923:52;5994:29;6013:9;5994:29;:::i;6034:592::-;6105:6;6113;6166:2;6154:9;6145:7;6141:23;6137:32;6134:52;;;6182:1;6179;6172:12;6134:52;6222:9;6209:23;6251:18;6292:2;6284:6;6281:14;6278:34;;;6308:1;6305;6298:12;6278:34;6346:6;6335:9;6331:22;6321:32;;6391:7;6384:4;6380:2;6376:13;6372:27;6362:55;;6413:1;6410;6403:12;6362:55;6453:2;6440:16;6479:2;6471:6;6468:14;6465:34;;;6495:1;6492;6485:12;6465:34;6540:7;6535:2;6526:6;6522:2;6518:15;6514:24;6511:37;6508:57;;;6561:1;6558;6551:12;6631:347;6696:6;6704;6757:2;6745:9;6736:7;6732:23;6728:32;6725:52;;;6773:1;6770;6763:12;6725:52;6796:29;6815:9;6796:29;:::i;:::-;6786:39;;6875:2;6864:9;6860:18;6847:32;6922:5;6915:13;6908:21;6901:5;6898:32;6888:60;;6944:1;6941;6934:12;6888:60;6967:5;6957:15;;;6631:347;;;;;:::o;6983:667::-;7078:6;7086;7094;7102;7155:3;7143:9;7134:7;7130:23;7126:33;7123:53;;;7172:1;7169;7162:12;7123:53;7195:29;7214:9;7195:29;:::i;:::-;7185:39;;7243:38;7277:2;7266:9;7262:18;7243:38;:::i;:::-;7233:48;;7328:2;7317:9;7313:18;7300:32;7290:42;;7383:2;7372:9;7368:18;7355:32;7410:18;7402:6;7399:30;7396:50;;;7442:1;7439;7432:12;7396:50;7465:22;;7518:4;7510:13;;7506:27;-1:-1:-1;7496:55:1;;7547:1;7544;7537:12;7496:55;7570:74;7636:7;7631:2;7618:16;7613:2;7609;7605:11;7570:74;:::i;:::-;7560:84;;;6983:667;;;;;;;:::o;7655:127::-;7716:10;7711:3;7707:20;7704:1;7697:31;7747:4;7744:1;7737:15;7771:4;7768:1;7761:15;7787:337;7928:2;7913:18;;7961:1;7950:13;;7940:144;;8006:10;8001:3;7997:20;7994:1;7987:31;8041:4;8038:1;8031:15;8069:4;8066:1;8059:15;7940:144;8093:25;;;7787:337;:::o;8129:260::-;8197:6;8205;8258:2;8246:9;8237:7;8233:23;8229:32;8226:52;;;8274:1;8271;8264:12;8226:52;8297:29;8316:9;8297:29;:::i;:::-;8287:39;;8345:38;8379:2;8368:9;8364:18;8345:38;:::i;8394:380::-;8473:1;8469:12;;;;8516;;;8537:61;;8591:4;8583:6;8579:17;8569:27;;8537:61;8644:2;8636:6;8633:14;8613:18;8610:38;8607:161;;;8690:10;8685:3;8681:20;8678:1;8671:31;8725:4;8722:1;8715:15;8753:4;8750:1;8743:15;8607:161;;8394:380;;;:::o;9611:409::-;9813:2;9795:21;;;9852:2;9832:18;;;9825:30;9891:34;9886:2;9871:18;;9864:62;-1:-1:-1;;;9957:2:1;9942:18;;9935:43;10010:3;9995:19;;9611:409::o;10025:127::-;10086:10;10081:3;10077:20;10074:1;10067:31;10117:4;10114:1;10107:15;10141:4;10138:1;10131:15;10157:168;10197:7;10263:1;10259;10255:6;10251:14;10248:1;10245:21;10240:1;10233:9;10226:17;10222:45;10219:71;;;10270:18;;:::i;:::-;-1:-1:-1;10310:9:1;;10157:168::o;10462:217::-;10502:1;10528;10518:132;;10572:10;10567:3;10563:20;10560:1;10553:31;10607:4;10604:1;10597:15;10635:4;10632:1;10625:15;10518:132;-1:-1:-1;10664:9:1;;10462:217::o;12680:127::-;12741:10;12736:3;12732:20;12729:1;12722:31;12772:4;12769:1;12762:15;12796:4;12793:1;12786:15;13151:135;13190:3;-1:-1:-1;;13211:17:1;;13208:43;;;13231:18;;:::i;:::-;-1:-1:-1;13278:1:1;13267:13;;13151:135::o;15302:637::-;15582:3;15620:6;15614:13;15636:53;15682:6;15677:3;15670:4;15662:6;15658:17;15636:53;:::i;:::-;15752:13;;15711:16;;;;15774:57;15752:13;15711:16;15808:4;15796:17;;15774:57;:::i;:::-;-1:-1:-1;;;15853:20:1;;15882:22;;;15931:1;15920:13;;15302:637;-1:-1:-1;;;;15302:637:1:o;16712:406::-;16914:2;16896:21;;;16953:2;16933:18;;;16926:30;16992:34;16987:2;16972:18;;16965:62;-1:-1:-1;;;17058:2:1;17043:18;;17036:40;17108:3;17093:19;;16712:406::o;17477:401::-;17679:2;17661:21;;;17718:2;17698:18;;;17691:30;17757:34;17752:2;17737:18;;17730:62;-1:-1:-1;;;17823:2:1;17808:18;;17801:35;17868:3;17853:19;;17477:401::o;18288:128::-;18328:3;18359:1;18355:6;18352:1;18349:13;18346:39;;;18365:18;;:::i;:::-;-1:-1:-1;18401:9:1;;18288:128::o;19131:414::-;19333:2;19315:21;;;19372:2;19352:18;;;19345:30;19411:34;19406:2;19391:18;;19384:62;-1:-1:-1;;;19477:2:1;19462:18;;19455:48;19535:3;19520:19;;19131:414::o;19972:489::-;-1:-1:-1;;;;;20241:15:1;;;20223:34;;20293:15;;20288:2;20273:18;;20266:43;20340:2;20325:18;;20318:34;;;20388:3;20383:2;20368:18;;20361:31;;;20166:4;;20409:46;;20435:19;;20427:6;20409:46;:::i;:::-;20401:54;19972:489;-1:-1:-1;;;;;;19972:489:1:o;20466:249::-;20535:6;20588:2;20576:9;20567:7;20563:23;20559:32;20556:52;;;20604:1;20601;20594:12;20556:52;20636:9;20630:16;20655:30;20679:5;20655:30;:::i;20720:125::-;20760:4;20788:1;20785;20782:8;20779:34;;;20793:18;;:::i;:::-;-1:-1:-1;20830:9:1;;20720:125::o;20850:127::-;20911:10;20906:3;20902:20;20899:1;20892:31;20942:4;20939:1;20932:15;20966:4;20963:1;20956:15

Swarm Source

ipfs://c7dc92f848a8fb7773a95fbfa02d74bace227e886294add9b4e97d107ef52174

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