Token

New NFT Access Pass (PASS)

ERC-721

Overview

Max Total Supply

1,415 PASS

Holders

108

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x8e8f404616c22d2a11ce61b9837e0cb53241fbcb

Filtered by Token Holder

0xfD851470BCCacEAC61F350FBbb4700D1A711abA9

Balance

7 PASS

0xfd851470bccaceac61f350fbbb4700d1a711aba9

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

NewNFT

Compiler Version

v0.8.17+commit.8df45f5f

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-03
*/

// SPDX-License-Identifier: MIT
// File: contracts/NewNFT.sol



// File 1: Address.sol

// OpenZeppelin Contracts v4.4.1 (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 functionCall(target, data, "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");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason 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 {
            // 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// FILE 2: 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) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// File 3: Strings.sol

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

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

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


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


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

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// File 4: 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 () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        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 {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}





// File 5: 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 6: 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`, 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 be 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: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * 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 Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

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



// File 7: 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 returns (string memory);
}




// File 8: 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 9: ERC721.sol

// OpenZeppelin Contracts (last updated v4.5.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: balance query for the zero address");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        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 virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        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 owner nor approved for all"
        );
        if (to.isContract()) {
            revert ("Token transfer to contract address is not allowed.");
        } else {
            _approve(to, tokenId);
        }
        // _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        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: transfer caller is not owner nor 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: transfer caller is not owner nor 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 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 _owners[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) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, 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);

        _balances[to] += 1;
        _owners[tokenId] = to;

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

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

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

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

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

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

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

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal 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);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {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 a {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 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 {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}





// File 10: 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 tokenId);

    /**
     * @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 11: 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 Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override {
        super._beforeTokenTransfer(from, to, tokenId);

        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 12: IERC721Receiver.sol

// OpenZeppelin Contracts v4.4.1 (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 `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}



// File 13: ERC721A.sol

pragma solidity ^0.8.0;


error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error BurnedQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, Ownable {
    using Address for address;
    using Strings for uint256;

    // Compiler will pack this into a single 256bit word.
    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

    // Compiler will pack this into a single 256bit word.
    struct AddressData {
        // Realistically, 2**64-1 is more than enough.
        uint64 balance;
        // Keeps track of mint count with minimal overhead for tokenomics.
        uint64 numberMinted;
        // Keeps track of burn count with minimal overhead for tokenomics.
        uint64 numberBurned;
    }

    // The tokenId of the next token to be minted.
    uint256 internal _currentIndex = 1;

    // The number of tokens burned.
    uint256 internal _burnCounter;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    //Allow all tokens to transfer to contract
    bool public allowedToContract = true;

    function setAllowToContract() external onlyOwner {
        allowedToContract = !allowedToContract;
    }

    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

    // Mapping owner address to address data
    mapping(address => AddressData) private _addressData;

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

    // Mapping token to allow to transfer to contract
    mapping(uint256 => bool) public _transferToContract;


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

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




    function setAllowTokenToContract(uint256 _tokenId, bool _allow) external onlyOwner {
        _transferToContract[_tokenId] = _allow;
    }

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex times
        unchecked {
            return _currentIndex - _burnCounter;    
        }
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     * This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
     * It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
     */
    function tokenByIndex(uint256 index) public view override returns (uint256) {
        uint256 numMintedSoFar = _currentIndex;
        uint256 tokenIdsIdx;

        // Counter overflow is impossible as the loop breaks when
        // uint256 i is equal to another uint256 numMintedSoFar.
        unchecked {
            for (uint256 i; i < numMintedSoFar; i++) {
                TokenOwnership memory ownership = _ownerships[i];
                if (!ownership.burned) {
                    if (tokenIdsIdx == index) {
                        return i;
                    }
                    tokenIdsIdx++;
                }
            }
        }
        revert TokenIndexOutOfBounds();
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     * This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
     * It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
        if (index >= balanceOf(owner)) revert OwnerIndexOutOfBounds();
        uint256 numMintedSoFar = _currentIndex;
        uint256 tokenIdsIdx;
        address currOwnershipAddr;

        // Counter overflow is impossible as the loop breaks when
        // uint256 i is equal to another uint256 numMintedSoFar.
        unchecked {
            for (uint256 i; i < numMintedSoFar; i++) {
                TokenOwnership memory ownership = _ownerships[i];
                if (ownership.burned) {
                    continue;
                }
                if (ownership.addr != address(0)) {
                    currOwnershipAddr = ownership.addr;
                }
                if (currOwnershipAddr == owner) {
                    if (tokenIdsIdx == index) {
                        return i;
                    }
                    tokenIdsIdx++;
                }
            }
        }

        // Execution should never reach this point.
        revert();
    }

    /**
     * @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 ||
            interfaceId == type(IERC721Enumerable).interfaceId ||
            super.supportsInterface(interfaceId);
    }

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

    function _numberMinted(address owner) internal view returns (uint256) {
        if (owner == address(0)) revert MintedQueryForZeroAddress();
        return uint256(_addressData[owner].numberMinted);
    }

    function _numberBurned(address owner) internal view returns (uint256) {
        if (owner == address(0)) revert BurnedQueryForZeroAddress();
        return uint256(_addressData[owner].numberBurned);
    }

    /**
     * Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around in the collection over time.
     */
    function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        uint256 curr = tokenId;

        unchecked {
            if (curr < _currentIndex) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (!ownership.burned) {
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                    // Invariant: 
                    // There will always be an ownership that has an address and is not burned 
                    // before an ownership that does not have an address and is not burned.
                    // Hence, curr will not underflow.
                    while (true) {
                        curr--;
                        ownership = _ownerships[curr];
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                    }
                }
            }
        }
        revert OwnerQueryForNonexistentToken();
    }

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

    /**
     * @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 virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        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 overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return '';
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public override {
        address owner = ERC721A.ownerOf(tokenId);
        if (to == owner) revert ApprovalToCurrentOwner();

        if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
            revert ApprovalCallerNotOwnerNorApproved();
        }
        if(!allowedToContract && !_transferToContract[tokenId]){
            if (to.isContract()) {
                revert ("Token transfer to contract address is not allowed.");
            } else {
                _approve(to, tokenId, owner);
            }
        } else {
            _approve(to, tokenId, owner);
        }
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public override {
        if (operator == _msgSender()) revert ApproveToCaller();
        
        if(!allowedToContract){
            if (operator.isContract()) {
                revert ("Token transfer to contract address is not allowed.");
            } else {
                _operatorApprovals[_msgSender()][operator] = approved;
                emit ApprovalForAll(_msgSender(), operator, approved);
            }
        } else {
            _operatorApprovals[_msgSender()][operator] = approved;
            emit ApprovalForAll(_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 {
        _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 {
        _transfer(from, to, tokenId);
        if (!_checkOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

    /**
     * @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`),
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        require(tokenId > 0, "Invalid TokenId");
        return tokenId < _currentIndex && !_ownerships[tokenId].burned;
    }

    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        _mint(to, quantity, _data, true);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _mint(
        address to,
        uint256 quantity,
        bytes memory _data,
        bool safe
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

            uint256 updatedIndex = startTokenId;

            for (uint256 i; i < quantity; i++) {
                emit Transfer(address(0), to, updatedIndex);
                if (safe && !_checkOnERC721Received(address(0), to, updatedIndex, _data)) {
                    revert TransferToNonERC721ReceiverImplementer();
                }
                updatedIndex++;
            }

            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * 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
    ) private {
        TokenOwnership memory prevOwnership = ownershipOf(tokenId);

        bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
            isApprovedForAll(prevOwnership.addr, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId, prevOwnership.addr);

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

            _ownerships[tokenId].addr = to;
            _ownerships[tokenId].startTimestamp = uint64(block.timestamp);

            // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            if (_ownerships[nextTokenId].addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId < _currentIndex) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, to, tokenId);
        _afterTokenTransfers(from, to, tokenId, 1);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        TokenOwnership memory prevOwnership = ownershipOf(tokenId);

        _beforeTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId, prevOwnership.addr);

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[prevOwnership.addr].balance -= 1;
            _addressData[prevOwnership.addr].numberBurned += 1;

            // Keep track of who burned the token, and the timestamp of burning.
            _ownerships[tokenId].addr = prevOwnership.addr;
            _ownerships[tokenId].startTimestamp = uint64(block.timestamp);
            _ownerships[tokenId].burned = true;

            // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            if (_ownerships[nextTokenId].addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId < _currentIndex) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(prevOwnership.addr, address(0), tokenId);
        _afterTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);

        // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
        unchecked { 
            _burnCounter++;
        }
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(
        address to,
        uint256 tokenId,
        address owner
    ) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    /**
     * @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(!allowedToContract && !_transferToContract[tokenId]){
            if (to.isContract()) {
                revert ("Token transfer to contract address is not allowed.");
            } else {
                return true;
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
     * minting.
     * And also called after one token has been burned.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}

// FILE 14: T12.sol


contract NewNFT is ERC721A {
    using Strings for uint256;
    uint256 public cost;
    uint256 public maxSupply;
    string private BASE_URI;
    uint256 public MAX_MINT_AMOUNT_PER_TX;
    bool public IS_SALE_ACTIVE;


    constructor(
        uint256 price,
        uint256 max_Supply,
        string memory baseUri,
        uint256 maxMintPerTx,
        bool isSaleActive
    ) ERC721A("New NFT Access Pass", "PASS") {
        cost = price;
        maxSupply = max_Supply;
        BASE_URI = baseUri;
        MAX_MINT_AMOUNT_PER_TX = maxMintPerTx;
        IS_SALE_ACTIVE = isSaleActive;
    }


    /** GETTERS **/

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

    /** SETTERS **/

    function setPrice(uint256 customPrice) external onlyOwner {
        cost = customPrice;
    }


    function lowerMaxSupply(uint256 newMaxSupply) external onlyOwner {
        require(newMaxSupply >= _currentIndex, "Invalid new max supply");
        maxSupply = newMaxSupply;
    }

    function setBaseURI(string memory customBaseURI_) external onlyOwner {
        BASE_URI = customBaseURI_;
    }

   

    function setMaxMintPerTx(uint256 maxMintPerTx) external onlyOwner {
        MAX_MINT_AMOUNT_PER_TX = maxMintPerTx;
    }

    function setSaleActive(bool saleIsActive) external onlyOwner {
        IS_SALE_ACTIVE = saleIsActive;
    }


    /** MINT **/

    modifier mintCompliance(uint256 _mintAmount) {
        require(
            _mintAmount > 0 && _mintAmount <= MAX_MINT_AMOUNT_PER_TX,
            "Invalid mint amount!"
        );
        require(
            _currentIndex + _mintAmount <= maxSupply,
            "Max supply exceeded!"
        );
        _;
    }

    function mint(uint256 _mintAmount)
        public
        payable
        mintCompliance(_mintAmount)
    {
        require(IS_SALE_ACTIVE, "Sale is not active!");

        uint256 price = cost * _mintAmount;

        require(msg.value >= price, "Insufficient funds!");

        _safeMint(msg.sender, _mintAmount);
    }

    function godMint(address _to, uint256 _mintAmount)
        public
        mintCompliance(_mintAmount)
        onlyOwner
    {
        _safeMint(_to, _mintAmount);
    }

    /** PAYOUT **/

    function withdraw() external onlyOwner {
        (bool success, ) = payable(msg.sender).call{value: address(this).balance}("");
        require(success, "Transfer failed.");
    }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"uint256","name":"max_Supply","type":"uint256"},{"internalType":"string","name":"baseUri","type":"string"},{"internalType":"uint256","name":"maxMintPerTx","type":"uint256"},{"internalType":"bool","name":"isSaleActive","type":"bool"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerIndexOutOfBounds","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TokenIndexOutOfBounds","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"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":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":"IS_SALE_ACTIVE","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_MINT_AMOUNT_PER_TX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"_transferToContract","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allowedToContract","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"cost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"_to","type":"address"},{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"godMint","outputs":[],"stateMutability":"nonpayable","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":[{"internalType":"uint256","name":"newMaxSupply","type":"uint256"}],"name":"lowerMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mint","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":"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":"setAllowToContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"bool","name":"_allow","type":"bool"}],"name":"setAllowTokenToContract","outputs":[],"stateMutability":"nonpayable","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":"customBaseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxMintPerTx","type":"uint256"}],"name":"setMaxMintPerTx","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"customPrice","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"saleIsActive","type":"bool"}],"name":"setSaleActive","outputs":[],"stateMutability":"nonpayable","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":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"nonpayable","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"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

00000000000000000000000000000000000000000000000000038d7ea4c680000000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000320000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002068747470733a2f2f6e66746d657461646174612e6c6976652f6e65774e46542f

-----Decoded View---------------
Arg [0] : price (uint256): 1000000000000000
Arg [1] : max_Supply (uint256): 3000
Arg [2] : baseUri (string): https://nftmetadata.live/newNFT/
Arg [3] : maxMintPerTx (uint256): 50
Arg [4] : isSaleActive (bool): True

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000038d7ea4c68000
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000bb8
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000032
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [6] : 68747470733a2f2f6e66746d657461646174612e6c6976652f6e65774e46542f

Deployed Bytecode Sourcemap

69595:2545:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52696:372;;;;;;;;;;-1:-1:-1;52696:372:0;;;;;:::i;:::-;;:::i;:::-;;;470:14:1;;463:22;445:41;;433:2;418:18;52696:372:0;;;;;;;;55306:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;57117:204::-;;;;;;;;;;-1:-1:-1;57117:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1502:32:1;;;1484:51;;1472:2;1457:18;57117:204:0;1338:203:1;56383:668:0;;;;;;;;;;-1:-1:-1;56383:668:0;;;;;:::i;:::-;;:::i;:::-;;69748:37;;;;;;;;;;;;;;;;;;;2129:25:1;;;2117:2;2102:18;69748:37:0;1983:177:1;69661:19:0;;;;;;;;;;;;;;;;49925:288;;;;;;;;;;-1:-1:-1;50178:12:0;;50162:13;;:28;49925:288;;58355:170;;;;;;;;;;-1:-1:-1;58355:170:0;;;;;:::i;:::-;;:::i;51519:1105::-;;;;;;;;;;-1:-1:-1;51519:1105:0;;;;;:::i;:::-;;:::i;71953:182::-;;;;;;;;;;;;;:::i;71749:174::-;;;;;;;;;;-1:-1:-1;71749:174:0;;;;;:::i;:::-;;:::i;58596:185::-;;;;;;;;;;-1:-1:-1;58596:185:0;;;;;:::i;:::-;;:::i;48526:36::-;;;;;;;;;;-1:-1:-1;48526:36:0;;;;;;;;50506:713;;;;;;;;;;-1:-1:-1;50506:713:0;;;;;:::i;:::-;;:::i;49585:140::-;;;;;;;;;;-1:-1:-1;49585:140:0;;;;;:::i;:::-;;:::i;70681:113::-;;;;;;;;;;-1:-1:-1;70681:113:0;;;;;:::i;:::-;;:::i;70809:122::-;;;;;;;;;;-1:-1:-1;70809:122:0;;;;;:::i;:::-;;:::i;55115:124::-;;;;;;;;;;-1:-1:-1;55115:124:0;;;;;:::i;:::-;;:::i;53132:206::-;;;;;;;;;;-1:-1:-1;53132:206:0;;;;;:::i;:::-;;:::i;14745:148::-;;;;;;;;;;;;;:::i;69792:26::-;;;;;;;;;;-1:-1:-1;69792:26:0;;;;;;;;48571:106;;;;;;;;;;;;;:::i;70939:109::-;;;;;;;;;;-1:-1:-1;70939:109:0;;;;;:::i;:::-;;:::i;14094:87::-;;;;;;;;;;-1:-1:-1;14140:7:0;14167:6;-1:-1:-1;;;;;14167:6:0;14094:87;;70385:95;;;;;;;;;;-1:-1:-1;70385:95:0;;;;;:::i;:::-;;:::i;55475:104::-;;;;;;;;;;;;;:::i;71409:332::-;;;;;;:::i;:::-;;:::i;57393:660::-;;;;;;;;;;-1:-1:-1;57393:660:0;;;;;:::i;:::-;;:::i;58852:342::-;;;;;;;;;;-1:-1:-1;58852:342:0;;;;;:::i;:::-;;:::i;49323:51::-;;;;;;;;;;-1:-1:-1;49323:51:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;70490:183;;;;;;;;;;-1:-1:-1;70490:183:0;;;;;:::i;:::-;;:::i;55650:329::-;;;;;;;;;;-1:-1:-1;55650:329:0;;;;;:::i;:::-;;:::i;69687:24::-;;;;;;;;;;;;;;;;58124:164;;;;;;;;;;-1:-1:-1;58124:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;58245:25:0;;;58221:4;58245:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;58124:164;15048:244;;;;;;;;;;-1:-1:-1;15048:244:0;;;;;:::i;:::-;;:::i;52696:372::-;52798:4;-1:-1:-1;;;;;;52835:40:0;;-1:-1:-1;;;52835:40:0;;:105;;-1:-1:-1;;;;;;;52892:48:0;;-1:-1:-1;;;52892:48:0;52835:105;:172;;;-1:-1:-1;;;;;;;52957:50:0;;-1:-1:-1;;;52957:50:0;52835:172;:225;;;-1:-1:-1;;;;;;;;;;22477:40:0;;;53024:36;52815:245;52696:372;-1:-1:-1;;52696:372:0:o;55306:100::-;55360:13;55393:5;55386:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55306:100;:::o;57117:204::-;57185:7;57210:16;57218:7;57210;:16::i;:::-;57205:64;;57235:34;;-1:-1:-1;;;57235:34:0;;;;;;;;;;;57205:64;-1:-1:-1;57289:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;57289:24:0;;57117:204::o;56383:668::-;56456:13;56472:24;56488:7;56472:15;:24::i;:::-;56456:40;;56517:5;-1:-1:-1;;;;;56511:11:0;:2;-1:-1:-1;;;;;56511:11:0;;56507:48;;56531:24;;-1:-1:-1;;;56531:24:0;;;;;;;;;;;56507:48;9200:10;-1:-1:-1;;;;;56572:21:0;;;;;;:63;;-1:-1:-1;56598:37:0;56615:5;9200:10;58124:164;:::i;56598:37::-;56597:38;56572:63;56568:138;;;56659:35;;-1:-1:-1;;;56659:35:0;;;;;;;;;;;56568:138;56720:17;;;;56719:18;:51;;;;-1:-1:-1;56742:28:0;;;;:19;:28;;;;;;;;56741:29;56719:51;56716:328;;;-1:-1:-1;;;;;56790:13:0;;1553:19;:23;56786:186;;56826:61;;-1:-1:-1;;;56826:61:0;;;;;;;:::i;:::-;;;;;;;;56786:186;56928:28;56937:2;56941:7;56950:5;56928:8;:28::i;:::-;56445:606;56383:668;;:::o;58355:170::-;58489:28;58499:4;58505:2;58509:7;58489:9;:28::i;51519:1105::-;51608:7;51641:16;51651:5;51641:9;:16::i;:::-;51632:5;:25;51628:61;;51666:23;;-1:-1:-1;;;51666:23:0;;;;;;;;;;;51628:61;51725:13;;51700:22;;;51975:557;51995:14;51991:1;:18;51975:557;;;52035:31;52069:14;;;:11;:14;;;;;;;;;52035:48;;;;;;;;;-1:-1:-1;;;;;52035:48:0;;;;-1:-1:-1;;;52035:48:0;;-1:-1:-1;;;;;52035:48:0;;;;;;;;-1:-1:-1;;;52035:48:0;;;;;;;;;;;;;;;;52102:73;;52147:8;;;52102:73;52197:14;;-1:-1:-1;;;;;52197:28:0;;52193:111;;52270:14;;;-1:-1:-1;52193:111:0;52347:5;-1:-1:-1;;;;;52326:26:0;:17;-1:-1:-1;;;;;52326:26:0;;52322:195;;52396:5;52381:11;:20;52377:85;;-1:-1:-1;52437:1:0;-1:-1:-1;52430:8:0;;-1:-1:-1;;;52430:8:0;52377:85;52484:13;;;;;52322:195;52016:516;51975:557;52011:3;;51975:557;;71953:182;14140:7;14167:6;-1:-1:-1;;;;;14167:6:0;9200:10;14314:23;14306:68;;;;-1:-1:-1;;;14306:68:0;;;;;;;:::i;:::-;72022:58:::1;::::0;72004:12:::1;::::0;72030:10:::1;::::0;72054:21:::1;::::0;72004:12;72022:58;72004:12;72022:58;72054:21;72030:10;72022:58:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72003:77;;;72099:7;72091:36;;;::::0;-1:-1:-1;;;72091:36:0;;7290:2:1;72091:36:0::1;::::0;::::1;7272:21:1::0;7329:2;7309:18;;;7302:30;-1:-1:-1;;;7348:18:1;;;7341:46;7404:18;;72091:36:0::1;7088:340:1::0;72091:36:0::1;71992:143;71953:182::o:0;71749:174::-;71840:11;71170:1;71156:11;:15;:56;;;;;71190:22;;71175:11;:37;;71156:56;71134:126;;;;-1:-1:-1;;;71134:126:0;;7635:2:1;71134:126:0;;;7617:21:1;7674:2;7654:18;;;7647:30;-1:-1:-1;;;7693:18:1;;;7686:50;7753:18;;71134:126:0;7433:344:1;71134:126:0;71324:9;;71309:11;71293:13;;:27;;;;:::i;:::-;:40;;71271:110;;;;-1:-1:-1;;;71271:110:0;;8246:2:1;71271:110:0;;;8228:21:1;8285:2;8265:18;;;8258:30;-1:-1:-1;;;8304:18:1;;;8297:50;8364:18;;71271:110:0;8044:344:1;71271:110:0;14140:7;14167:6;-1:-1:-1;;;;;14167:6:0;9200:10;14314:23:::1;14306:68;;;;-1:-1:-1::0;;;14306:68:0::1;;;;;;;:::i;:::-;71888:27:::2;71898:3;71903:11;71888:9;:27::i;58596:185::-:0;58734:39;58751:4;58757:2;58761:7;58734:39;;;;;;;;;;;;:16;:39::i;50506:713::-;50618:13;;50573:7;;;;50832:328;50852:14;50848:1;:18;50832:328;;;50892:31;50926:14;;;:11;:14;;;;;;;;;50892:48;;;;;;;;;-1:-1:-1;;;;;50892:48:0;;;;-1:-1:-1;;;50892:48:0;;-1:-1:-1;;;;;50892:48:0;;;;;;;;-1:-1:-1;;;50892:48:0;;;;;;;;;;;;;;50959:186;;51024:5;51009:11;:20;51005:85;;-1:-1:-1;51065:1:0;50506:713;-1:-1:-1;;;;50506:713:0:o;51005:85::-;51112:13;;;;;50959:186;-1:-1:-1;50868:3:0;;50832:328;;;;51188:23;;-1:-1:-1;;;51188:23:0;;;;;;;;;;;49585:140;14140:7;14167:6;-1:-1:-1;;;;;14167:6:0;9200:10;14314:23;14306:68;;;;-1:-1:-1;;;14306:68:0;;;;;;;:::i;:::-;49679:29:::1;::::0;;;:19:::1;:29;::::0;;;;;:38;;-1:-1:-1;;49679:38:0::1;::::0;::::1;;::::0;;;::::1;::::0;;49585:140::o;70681:113::-;14140:7;14167:6;-1:-1:-1;;;;;14167:6:0;9200:10;14314:23;14306:68;;;;-1:-1:-1;;;14306:68:0;;;;;;;:::i;:::-;70761:8:::1;:25;70772:14:::0;70761:8;:25:::1;:::i;:::-;;70681:113:::0;:::o;70809:122::-;14140:7;14167:6;-1:-1:-1;;;;;14167:6:0;9200:10;14314:23;14306:68;;;;-1:-1:-1;;;14306:68:0;;;;;;;:::i;:::-;70886:22:::1;:37:::0;70809:122::o;55115:124::-;55179:7;55206:20;55218:7;55206:11;:20::i;:::-;:25;;55115:124;-1:-1:-1;;55115:124:0:o;53132:206::-;53196:7;-1:-1:-1;;;;;53220:19:0;;53216:60;;53248:28;;-1:-1:-1;;;53248:28:0;;;;;;;;;;;53216:60;-1:-1:-1;;;;;;53302:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;53302:27:0;;53132:206::o;14745:148::-;14140:7;14167:6;-1:-1:-1;;;;;14167:6:0;9200:10;14314:23;14306:68;;;;-1:-1:-1;;;14306:68:0;;;;;;;:::i;:::-;14852:1:::1;14836:6:::0;;14815:40:::1;::::0;-1:-1:-1;;;;;14836:6:0;;::::1;::::0;14815:40:::1;::::0;14852:1;;14815:40:::1;14883:1;14866:19:::0;;-1:-1:-1;;;;;;14866:19:0::1;::::0;;14745:148::o;48571:106::-;14140:7;14167:6;-1:-1:-1;;;;;14167:6:0;9200:10;14314:23;14306:68;;;;-1:-1:-1;;;14306:68:0;;;;;;;:::i;:::-;48652:17:::1;::::0;;-1:-1:-1;;48631:38:0;::::1;48652:17;::::0;;::::1;48651:18;48631:38;::::0;;48571:106::o;70939:109::-;14140:7;14167:6;-1:-1:-1;;;;;14167:6:0;9200:10;14314:23;14306:68;;;;-1:-1:-1;;;14306:68:0;;;;;;;:::i;:::-;71011:14:::1;:29:::0;;-1:-1:-1;;71011:29:0::1;::::0;::::1;;::::0;;;::::1;::::0;;70939:109::o;70385:95::-;14140:7;14167:6;-1:-1:-1;;;;;14167:6:0;9200:10;14314:23;14306:68;;;;-1:-1:-1;;;14306:68:0;;;;;;;:::i;:::-;70454:4:::1;:18:::0;70385:95::o;55475:104::-;55531:13;55564:7;55557:14;;;;;:::i;71409:332::-;71501:11;71170:1;71156:11;:15;:56;;;;;71190:22;;71175:11;:37;;71156:56;71134:126;;;;-1:-1:-1;;;71134:126:0;;7635:2:1;71134:126:0;;;7617:21:1;7674:2;7654:18;;;7647:30;-1:-1:-1;;;7693:18:1;;;7686:50;7753:18;;71134:126:0;7433:344:1;71134:126:0;71324:9;;71309:11;71293:13;;:27;;;;:::i;:::-;:40;;71271:110;;;;-1:-1:-1;;;71271:110:0;;8246:2:1;71271:110:0;;;8228:21:1;8285:2;8265:18;;;8258:30;-1:-1:-1;;;8304:18:1;;;8297:50;8364:18;;71271:110:0;8044:344:1;71271:110:0;71538:14:::1;::::0;::::1;;71530:46;;;::::0;-1:-1:-1;;;71530:46:0;;10799:2:1;71530:46:0::1;::::0;::::1;10781:21:1::0;10838:2;10818:18;;;10811:30;-1:-1:-1;;;10857:18:1;;;10850:49;10916:18;;71530:46:0::1;10597:343:1::0;71530:46:0::1;71589:13;71612:11;71605:4;;:18;;;;:::i;:::-;71589:34;;71657:5;71644:9;:18;;71636:50;;;::::0;-1:-1:-1;;;71636:50:0;;11320:2:1;71636:50:0::1;::::0;::::1;11302:21:1::0;11359:2;11339:18;;;11332:30;-1:-1:-1;;;11378:18:1;;;11371:49;11437:18;;71636:50:0::1;11118:343:1::0;71636:50:0::1;71699:34;71709:10;71721:11;71699:9;:34::i;57393:660::-:0;9200:10;-1:-1:-1;;;;;57484:24:0;;;57480:54;;57517:17;;-1:-1:-1;;;57517:17:0;;;;;;;;;;;57480:54;57559:17;;;;57555:491;;-1:-1:-1;;;;;57596:19:0;;1553;:23;57592:289;;57638:61;;-1:-1:-1;;;57638:61:0;;;;;;;:::i;57592:289::-;9200:10;57740:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;57740:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;57740:53:0;;;;;;;;;;57817:48;;445:41:1;;;57740:42:0;;9200:10;57817:48;;418:18:1;57817:48:0;;;;;;;70761:25:::1;70681:113:::0;:::o;58852:342::-;59019:28;59029:4;59035:2;59039:7;59019:9;:28::i;:::-;59063:48;59086:4;59092:2;59096:7;59105:5;59063:22;:48::i;:::-;59058:129;;59135:40;;-1:-1:-1;;;59135:40:0;;;;;;;;;;;59058:129;58852:342;;;;:::o;70490:183::-;14140:7;14167:6;-1:-1:-1;;;;;14167:6:0;9200:10;14314:23;14306:68;;;;-1:-1:-1;;;14306:68:0;;;;;;;:::i;:::-;70590:13:::1;;70574:12;:29;;70566:64;;;::::0;-1:-1:-1;;;70566:64:0;;11668:2:1;70566:64:0::1;::::0;::::1;11650:21:1::0;11707:2;11687:18;;;11680:30;-1:-1:-1;;;11726:18:1;;;11719:52;11788:18;;70566:64:0::1;11466:346:1::0;70566:64:0::1;70641:9;:24:::0;70490:183::o;55650:329::-;55718:13;55752:16;55760:7;55752;:16::i;:::-;55744:76;;;;-1:-1:-1;;;55744:76:0;;12019:2:1;55744:76:0;;;12001:21:1;12058:2;12038:18;;;12031:30;12097:34;12077:18;;;12070:62;-1:-1:-1;;;12148:18:1;;;12141:45;12203:19;;55744:76:0;11817:411:1;55744:76:0;55833:21;55857:10;:8;:10::i;:::-;55833:34;;55909:1;55891:7;55885:21;:25;:86;;;;;;;;;;;;;;;;;55937:7;55946:18;:7;:16;:18::i;:::-;55920:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;55885:86;55878:93;55650:329;-1:-1:-1;;;55650:329:0:o;15048:244::-;14140:7;14167:6;-1:-1:-1;;;;;14167:6:0;9200:10;14314:23;14306:68;;;;-1:-1:-1;;;14306:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;15137:22:0;::::1;15129:73;;;::::0;-1:-1:-1;;;15129:73:0;;12936:2:1;15129:73:0::1;::::0;::::1;12918:21:1::0;12975:2;12955:18;;;12948:30;13014:34;12994:18;;;12987:62;-1:-1:-1;;;13065:18:1;;;13058:36;13111:19;;15129:73:0::1;12734:402:1::0;15129:73:0::1;15239:6;::::0;;15218:38:::1;::::0;-1:-1:-1;;;;;15218:38:0;;::::1;::::0;15239:6;::::1;::::0;15218:38:::1;::::0;::::1;15267:6;:17:::0;;-1:-1:-1;;;;;;15267:17:0::1;-1:-1:-1::0;;;;;15267:17:0;;;::::1;::::0;;;::::1;::::0;;15048:244::o;59449:194::-;59506:4;59541:1;59531:7;:11;59523:39;;;;-1:-1:-1;;;59523:39:0;;13343:2:1;59523:39:0;;;13325:21:1;13382:2;13362:18;;;13355:30;-1:-1:-1;;;13401:18:1;;;13394:45;13456:18;;59523:39:0;13141:339:1;59523:39:0;59590:13;;59580:7;:23;:55;;;;-1:-1:-1;;59608:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;59608:27:0;;;;59607:28;;59449:194::o;66705:196::-;66820:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;66820:29:0;-1:-1:-1;;;;;66820:29:0;;;;;;;;;66865:28;;66820:24;;66865:28;;;;;;;66705:196;;;:::o;62206:2112::-;62321:35;62359:20;62371:7;62359:11;:20::i;:::-;62434:18;;62321:58;;-1:-1:-1;62392:22:0;;-1:-1:-1;;;;;62418:34:0;9200:10;-1:-1:-1;;;;;62418:34:0;;:101;;;-1:-1:-1;62486:18:0;;62469:50;;9200:10;58124:164;:::i;62469:50::-;62418:154;;;-1:-1:-1;9200:10:0;62536:20;62548:7;62536:11;:20::i;:::-;-1:-1:-1;;;;;62536:36:0;;62418:154;62392:181;;62591:17;62586:66;;62617:35;;-1:-1:-1;;;62617:35:0;;;;;;;;;;;62586:66;62689:4;-1:-1:-1;;;;;62667:26:0;:13;:18;;;-1:-1:-1;;;;;62667:26:0;;62663:67;;62702:28;;-1:-1:-1;;;62702:28:0;;;;;;;;;;;62663:67;-1:-1:-1;;;;;62745:16:0;;62741:52;;62770:23;;-1:-1:-1;;;62770:23:0;;;;;;;;;;;62741:52;62914:49;62931:1;62935:7;62944:13;:18;;;62914:8;:49::i;:::-;-1:-1:-1;;;;;63259:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;63259:31:0;;;-1:-1:-1;;;;;63259:31:0;;;-1:-1:-1;;63259:31:0;;;;;;;63305:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;63305:29:0;;;;;;;;;;;63351:20;;;:11;:20;;;;;;:30;;-1:-1:-1;;;;;;63396:61:0;;;;-1:-1:-1;;;63441:15:0;63396:61;;;;;;;;;;;63731:11;;;63761:24;;;;;:29;63731:11;;63761:29;63757:445;;63986:13;;63972:11;:27;63968:219;;;64056:18;;;64024:24;;;:11;:24;;;;;;;;:50;;64139:28;;;;-1:-1:-1;;;;;64097:70:0;-1:-1:-1;;;64097:70:0;-1:-1:-1;;;;;;64097:70:0;;;-1:-1:-1;;;;;64024:50:0;;;64097:70;;;;;;;63968:219;63234:979;64249:7;64245:2;-1:-1:-1;;;;;64230:27:0;64239:4;-1:-1:-1;;;;;64230:27:0;;;;;;;;;;;64268:42;62310:2008;;62206:2112;;;:::o;59651:104::-;59720:27;59730:2;59734:8;59720:27;;;;;;;;;;;;:9;:27::i;53970:1083::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;54136:13:0;;54080:7;;54129:20;;54125:861;;;54170:31;54204:17;;;:11;:17;;;;;;;;;54170:51;;;;;;;;;-1:-1:-1;;;;;54170:51:0;;;;-1:-1:-1;;;54170:51:0;;-1:-1:-1;;;;;54170:51:0;;;;;;;;-1:-1:-1;;;54170:51:0;;;;;;;;;;;;;;54240:731;;54290:14;;-1:-1:-1;;;;;54290:28:0;;54286:101;;54354:9;53970:1083;-1:-1:-1;;;53970:1083:0:o;54286:101::-;-1:-1:-1;;;54731:6:0;54776:17;;;;:11;:17;;;;;;;;;54764:29;;;;;;;;;-1:-1:-1;;;;;54764:29:0;;;;;-1:-1:-1;;;54764:29:0;;-1:-1:-1;;;;;54764:29:0;;;;;;;;-1:-1:-1;;;54764:29:0;;;;;;;;;;;;;54824:28;54820:109;;54892:9;53970:1083;-1:-1:-1;;;53970:1083:0:o;54820:109::-;54691:261;;;54151:835;54125:861;55014:31;;-1:-1:-1;;;55014:31:0;;;;;;;;;;;67466:473;67642:17;;67621:4;;67642:17;;67641:18;:51;;;;-1:-1:-1;67664:28:0;;;;:19;:28;;;;;;;;67663:29;67641:51;67638:294;;;-1:-1:-1;;;;;67712:13:0;;1553:19;:23;67708:169;;67748:61;;-1:-1:-1;;;67748:61:0;;;;;;;:::i;67708:169::-;-1:-1:-1;67857:4:0;67638:294;67466:473;;;;;;:::o;70245:109::-;70305:13;70338:8;70331:15;;;;;:::i;9803:723::-;9859:13;10080:5;10089:1;10080:10;10076:53;;-1:-1:-1;;10107:10:0;;;;;;;;;;;;-1:-1:-1;;;10107:10:0;;;;;9803:723::o;10076:53::-;10154:5;10139:12;10195:78;10202:9;;10195:78;;10228:8;;;;:::i;:::-;;-1:-1:-1;10251:10:0;;-1:-1:-1;10259:2:0;10251:10;;:::i;:::-;;;10195:78;;;10283:19;10315:6;-1:-1:-1;;;;;10305:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;10305:17:0;;10283:39;;10333:154;10340:10;;10333:154;;10367:11;10377:1;10367:11;;:::i;:::-;;-1:-1:-1;10436:10:0;10444:2;10436:5;:10;:::i;:::-;10423:24;;:2;:24;:::i;:::-;10410:39;;10393:6;10400;10393:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;10393:56:0;;;;;;;;-1:-1:-1;10464:11:0;10473:2;10464:11;;:::i;:::-;;;10333:154;;60118:163;60241:32;60247:2;60251:8;60261:5;60268:4;60702:13;;-1:-1:-1;;;;;60730:16:0;;60726:48;;60755:19;;-1:-1:-1;;;60755:19:0;;;;;;;;;;;60726:48;60789:8;60801:1;60789:13;60785:44;;60811:18;;-1:-1:-1;;;60811:18:0;;;;;;;;;;;60785:44;-1:-1:-1;;;;;61180:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;61239:49:0;;-1:-1:-1;;;;;61180:44:0;;;;;;;61239:49;;;;-1:-1:-1;;61180:44:0;;;;;;61239:49;;;;;;;;;;;;;;;;61305:25;;;:11;:25;;;;;:35;;-1:-1:-1;;;;;;61355:66:0;;;;-1:-1:-1;;;61405:15:0;61355:66;;;;;;;;;;;61305:25;;61490:328;61510:8;61506:1;:12;61490:328;;;61549:38;;61574:12;;-1:-1:-1;;;;;61549:38:0;;;61566:1;;61549:38;;61566:1;;61549:38;61610:4;:68;;;;;61619:59;61650:1;61654:2;61658:12;61672:5;61619:22;:59::i;:::-;61618:60;61610:68;61606:164;;;61710:40;;-1:-1:-1;;;61710:40:0;;;;;;;;;;;61606:164;61788:14;;;;;61520:3;61490:328;;;-1:-1:-1;61834:13:0;:28;61884:60;58852:342;14:286:1;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;167:23;;-1:-1:-1;;;;;;219:32:1;;209:43;;199:71;;266:1;263;256:12;497:250;582:1;592:113;606:6;603:1;600:13;592:113;;;682:11;;;676:18;663:11;;;656:39;628:2;621:10;592:113;;;-1:-1:-1;;739:1:1;721:16;;714:27;497:250::o;752:396::-;901:2;890:9;883:21;864:4;933:6;927:13;976:6;971:2;960:9;956:18;949:34;992:79;1064:6;1059:2;1048:9;1044:18;1039:2;1031:6;1027:15;992:79;:::i;:::-;1132:2;1111:15;-1:-1:-1;;1107:29:1;1092:45;;;;1139:2;1088:54;;752:396;-1:-1:-1;;752:396:1:o;1153:180::-;1212:6;1265:2;1253:9;1244:7;1240:23;1236:32;1233:52;;;1281:1;1278;1271:12;1233:52;-1:-1:-1;1304:23:1;;1153:180;-1:-1:-1;1153:180:1:o;1546:173::-;1614:20;;-1:-1:-1;;;;;1663:31:1;;1653:42;;1643:70;;1709:1;1706;1699:12;1643:70;1546:173;;;:::o;1724:254::-;1792:6;1800;1853:2;1841:9;1832:7;1828:23;1824:32;1821:52;;;1869:1;1866;1859:12;1821:52;1892:29;1911:9;1892:29;:::i;:::-;1882:39;1968:2;1953:18;;;;1940:32;;-1:-1:-1;;;1724:254:1:o;2165:328::-;2242:6;2250;2258;2311:2;2299:9;2290:7;2286:23;2282:32;2279:52;;;2327:1;2324;2317:12;2279:52;2350:29;2369:9;2350:29;:::i;:::-;2340:39;;2398:38;2432:2;2421:9;2417:18;2398:38;:::i;:::-;2388:48;;2483:2;2472:9;2468:18;2455:32;2445:42;;2165:328;;;;;:::o;2498:160::-;2563:20;;2619:13;;2612:21;2602:32;;2592:60;;2648:1;2645;2638:12;2663:248;2728:6;2736;2789:2;2777:9;2768:7;2764:23;2760:32;2757:52;;;2805:1;2802;2795:12;2757:52;2841:9;2828:23;2818:33;;2870:35;2901:2;2890:9;2886:18;2870:35;:::i;:::-;2860:45;;2663:248;;;;;:::o;2916:127::-;2977:10;2972:3;2968:20;2965:1;2958:31;3008:4;3005:1;2998:15;3032:4;3029:1;3022:15;3048:632;3113:5;-1:-1:-1;;;;;3184:2:1;3176:6;3173:14;3170:40;;;3190:18;;:::i;:::-;3265:2;3259:9;3233:2;3319:15;;-1:-1:-1;;3315:24:1;;;3341:2;3311:33;3307:42;3295:55;;;3365:18;;;3385:22;;;3362:46;3359:72;;;3411:18;;:::i;:::-;3451:10;3447:2;3440:22;3480:6;3471:15;;3510:6;3502;3495:22;3550:3;3541:6;3536:3;3532:16;3529:25;3526:45;;;3567:1;3564;3557:12;3526:45;3617:6;3612:3;3605:4;3597:6;3593:17;3580:44;3672:1;3665:4;3656:6;3648;3644:19;3640:30;3633:41;;;;3048:632;;;;;:::o;3685:451::-;3754:6;3807:2;3795:9;3786:7;3782:23;3778:32;3775:52;;;3823:1;3820;3813:12;3775:52;3863:9;3850:23;-1:-1:-1;;;;;3888:6:1;3885:30;3882:50;;;3928:1;3925;3918:12;3882:50;3951:22;;4004:4;3996:13;;3992:27;-1:-1:-1;3982:55:1;;4033:1;4030;4023:12;3982:55;4056:74;4122:7;4117:2;4104:16;4099:2;4095;4091:11;4056:74;:::i;4141:186::-;4200:6;4253:2;4241:9;4232:7;4228:23;4224:32;4221:52;;;4269:1;4266;4259:12;4221:52;4292:29;4311:9;4292:29;:::i;4332:180::-;4388:6;4441:2;4429:9;4420:7;4416:23;4412:32;4409:52;;;4457:1;4454;4447:12;4409:52;4480:26;4496:9;4480:26;:::i;4517:254::-;4582:6;4590;4643:2;4631:9;4622:7;4618:23;4614:32;4611:52;;;4659:1;4656;4649:12;4611:52;4682:29;4701:9;4682:29;:::i;:::-;4672:39;;4730:35;4761:2;4750:9;4746:18;4730:35;:::i;4776:667::-;4871:6;4879;4887;4895;4948:3;4936:9;4927:7;4923:23;4919:33;4916:53;;;4965:1;4962;4955:12;4916:53;4988:29;5007:9;4988:29;:::i;:::-;4978:39;;5036:38;5070:2;5059:9;5055:18;5036:38;:::i;:::-;5026:48;;5121:2;5110:9;5106:18;5093:32;5083:42;;5176:2;5165:9;5161:18;5148:32;-1:-1:-1;;;;;5195:6:1;5192:30;5189:50;;;5235:1;5232;5225:12;5189:50;5258:22;;5311:4;5303:13;;5299:27;-1:-1:-1;5289:55:1;;5340:1;5337;5330:12;5289:55;5363:74;5429:7;5424:2;5411:16;5406:2;5402;5398:11;5363:74;:::i;:::-;5353:84;;;4776:667;;;;;;;:::o;5448:260::-;5516:6;5524;5577:2;5565:9;5556:7;5552:23;5548:32;5545:52;;;5593:1;5590;5583:12;5545:52;5616:29;5635:9;5616:29;:::i;:::-;5606:39;;5664:38;5698:2;5687:9;5683:18;5664:38;:::i;5713:380::-;5792:1;5788:12;;;;5835;;;5856:61;;5910:4;5902:6;5898:17;5888:27;;5856:61;5963:2;5955:6;5952:14;5932:18;5929:38;5926:161;;6009:10;6004:3;6000:20;5997:1;5990:31;6044:4;6041:1;6034:15;6072:4;6069:1;6062:15;5926:161;;5713:380;;;:::o;6098:414::-;6300:2;6282:21;;;6339:2;6319:18;;;6312:30;6378:34;6373:2;6358:18;;6351:62;-1:-1:-1;;;6444:2:1;6429:18;;6422:48;6502:3;6487:19;;6098:414::o;6517:356::-;6719:2;6701:21;;;6738:18;;;6731:30;6797:34;6792:2;6777:18;;6770:62;6864:2;6849:18;;6517:356::o;7782:127::-;7843:10;7838:3;7834:20;7831:1;7824:31;7874:4;7871:1;7864:15;7898:4;7895:1;7888:15;7914:125;7979:9;;;8000:10;;;7997:36;;;8013:18;;:::i;8519:545::-;8621:2;8616:3;8613:11;8610:448;;;8657:1;8682:5;8678:2;8671:17;8727:4;8723:2;8713:19;8797:2;8785:10;8781:19;8778:1;8774:27;8768:4;8764:38;8833:4;8821:10;8818:20;8815:47;;;-1:-1:-1;8856:4:1;8815:47;8911:2;8906:3;8902:12;8899:1;8895:20;8889:4;8885:31;8875:41;;8966:82;8984:2;8977:5;8974:13;8966:82;;;9029:17;;;9010:1;8999:13;8966:82;;;8970:3;;;8519:545;;;:::o;9240:1352::-;9366:3;9360:10;-1:-1:-1;;;;;9385:6:1;9382:30;9379:56;;;9415:18;;:::i;:::-;9444:97;9534:6;9494:38;9526:4;9520:11;9494:38;:::i;:::-;9488:4;9444:97;:::i;:::-;9596:4;;9660:2;9649:14;;9677:1;9672:663;;;;10379:1;10396:6;10393:89;;;-1:-1:-1;10448:19:1;;;10442:26;10393:89;-1:-1:-1;;9197:1:1;9193:11;;;9189:24;9185:29;9175:40;9221:1;9217:11;;;9172:57;10495:81;;9642:944;;9672:663;8466:1;8459:14;;;8503:4;8490:18;;-1:-1:-1;;9708:20:1;;;9826:236;9840:7;9837:1;9834:14;9826:236;;;9929:19;;;9923:26;9908:42;;10021:27;;;;9989:1;9977:14;;;;9856:19;;9826:236;;;9830:3;10090:6;10081:7;10078:19;10075:201;;;10151:19;;;10145:26;-1:-1:-1;;10234:1:1;10230:14;;;10246:3;10226:24;10222:37;10218:42;10203:58;10188:74;;10075:201;-1:-1:-1;;;;;10322:1:1;10306:14;;;10302:22;10289:36;;-1:-1:-1;9240:1352:1:o;10945:168::-;11018:9;;;11049;;11066:15;;;11060:22;;11046:37;11036:71;;11087:18;;:::i;12233:496::-;12412:3;12450:6;12444:13;12466:66;12525:6;12520:3;12513:4;12505:6;12501:17;12466:66;:::i;:::-;12595:13;;12554:16;;;;12617:70;12595:13;12554:16;12664:4;12652:17;;12617:70;:::i;:::-;12703:20;;12233:496;-1:-1:-1;;;;12233:496:1:o;13485:135::-;13524:3;13545:17;;;13542:43;;13565:18;;:::i;:::-;-1:-1:-1;13612:1:1;13601:13;;13485:135::o;13625:127::-;13686:10;13681:3;13677:20;13674:1;13667:31;13717:4;13714:1;13707:15;13741:4;13738:1;13731:15;13757:120;13797:1;13823;13813:35;;13828:18;;:::i;:::-;-1:-1:-1;13862:9:1;;13757:120::o;13882:128::-;13949:9;;;13970:11;;;13967:37;;;13984:18;;:::i;14015:112::-;14047:1;14073;14063:35;;14078:18;;:::i;:::-;-1:-1:-1;14112:9:1;;14015:112::o;14132:127::-;14193:10;14188:3;14184:20;14181:1;14174:31;14224:4;14221:1;14214:15;14248:4;14245:1;14238:15

Swarm Source

ipfs://0be4d9d620d0dac2c84e60cbdf86d3a089338eb88ae1b7b09e8fbaac4da45f25

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