Token

LIVE LIKE A DOG (LLD)

ERC-721

Overview

Max Total Supply

718 LLD

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x79480f30c79b60581bb3276dd433679e931a1000

Filtered by Token Holder

0x5C1643e4caa7a6d2eCD37Aca614c5B189b16e803

Balance

30 LLD

0x5c1643e4caa7a6d2ecd37aca614c5b189b16e803

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

LIVE_LIKE_A_DOG

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

// SPDX-License-Identifier: MIT
// File: LIVE_LIKE_A_DOG_flat.sol


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


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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;


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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

// File: @openzeppelin/contracts/utils/cryptography/MerkleProof.sol


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

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

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


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

pragma solidity ^0.8.0;

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

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

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

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

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

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

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

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

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

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

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


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

pragma solidity ^0.8.0;

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

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

// File: contracts/ERC721A.sol


// Creator: Chiru Labs

pragma solidity ^0.8.4;









error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error UnableDetermineTokenOwner();
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..).
 *
 * Does not support burning tokens to address(0).
 *
 * Assumes that an owner cannot have more than the 2**128 - 1 (max value of uint128) of supply
 */
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
    using Address for address;
    using Strings for uint256;

    struct TokenOwnership {
        address addr;
        uint64 startTimestamp;
    }

    struct AddressData {
        uint128 balance;
        uint128 numberMinted;
    }

    uint256 internal _currentIndex;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view override returns (uint256) {
        if (index >= totalSupply()) revert TokenIndexOutOfBounds();
        return index;
    }

    /**
     * @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)
  {
    require(index < balanceOf(owner), "ERC721A: owner index out of bounds");
    uint256 numMintedSoFar = totalSupply();
    uint256 tokenIdsIdx = 0;
    address currOwnershipAddr = address(0);
    for (uint256 i = 0; i < numMintedSoFar; i++) {
      TokenOwnership memory ownership = _ownerships[i];
      if (ownership.addr != address(0)) {
        currOwnershipAddr = ownership.addr;
      }
      if (currOwnershipAddr == owner) {
        if (tokenIdsIdx == index) {
          return i;
        }
        tokenIdsIdx++;
      }
    }
    revert("ERC721A: unable to get token of owner by index");
  }

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

    /**
     * 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) {
        if (!_exists(tokenId)) revert OwnerQueryForNonexistentToken();

        unchecked {
            for (uint256 curr = tokenId; curr >= 0; curr--) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (ownership.addr != address(0)) {
                    return ownership;
                }
            }
        }

        revert UnableDetermineTokenOwner();
    }

    /**
     * @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 view virtual override returns (string memory) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

        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();

        _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();

        _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 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) {
        return tokenId < _currentIndex;
    }

    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 > 3.4e38 (2**128) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.56e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint128(quantity);
            _addressData[to].numberMinted += uint128(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 ||
            getApproved(tokenId) == _msgSender() ||
            isApprovedForAll(prevOwnership.addr, _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)) {
                if (_exists(nextTokenId)) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

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

    /**
     * @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 (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver(to).onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) revert TransferToNonERC721ReceiverImplementer();
                else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     *
     * 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`.
     */
    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.
     *
     * 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` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}
// File: @openzeppelin/contracts/access/Ownable.sol


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

pragma solidity ^0.8.0;


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

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

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

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

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

// File: contracts/LIVE_LIKE_A_DOG.sol



pragma solidity >= 0.8.6 <=0.9.0;






contract LIVE_LIKE_A_DOG is Ownable, ReentrancyGuard, ERC721A {
using Strings for uint256;

  uint256 public maxMintAmount = 30;
  mapping(address => bool) public whitelist;
  uint256 Price = 0.00149 ether;
  uint256 public maxSupply = 22023;
  bool public paused = true;
  bool public revealed = false;
  uint256 public constant WHITELIST_PRICE = 0 ether;
  string private  baseTokenUri;
  string public   placeholderTokenUri;

    struct SaleConfig {
    uint256 Price;
    uint256 AmountForWhitelist;
  }

  SaleConfig public saleConfig;

  constructor() ERC721A("LIVE LIKE A DOG", "LLD") {
     
  whitelist[0x57648447820f4a8526F4Ca52E8a36A7a300860e5] = true; whitelist[0x1F84bfd68A9d5033Ddfd36354a47baCB77C6a878] = true; whitelist[0x25A577A021ca9F2376D6487d99AB759C3c60a696] = true; whitelist[0x2f37E25d543ec6C29E1E5AafdDD3Bb4Bb931f725] = true; whitelist[0x40e4CfBFCC0a518ff0dd77F4D326611BE341E123] = true; whitelist[0x42205cE26Bbd01E51050052d22Bb95b52EEf2527] = true; whitelist[0x5C1643e4caa7a6d2eCD37Aca614c5B189b16e803] = true; whitelist[0x9D8682930aaa7d80cf343390ADd8D4E3545226Ab] = true; whitelist[0xB70eF825C8098b6c0857bba9AD780df9e75bFb2A] = true; whitelist[0xb7a4cDE186fF1D89CB5754F932c3e5Ba538b65c5] = true; whitelist[0xd3CA7303626563CD27D1A57b0bB731bf4B63013F] = true; whitelist[0xE78F9a3BB3A364CB8Bc35f264D2B9CeabA2e1D52] = true; whitelist[0x893D3F68fD0f1Cdaa5DC45b98055d80392F785C9] = true; whitelist[0x2702Ff48e2B708A3BEe78C01c5E87D7595519EB1] = true; whitelist[0xA4F6080e72DB588591E85a559E5BCb37219B9CF4] = true; whitelist[0x01A275A5FAf0a019aFD01586De63634DDB55d900] = true; whitelist[0x0565cCFe332F638a287A2EdfFa937eb0307922B5] = true; whitelist[0x1244050335847B8b59Dbc8C05103d2bA1517B361] = true; whitelist[0x1acbB8fe61fB4ed8395F29A622a548555D88CF55] = true; whitelist[0x205698CE308ac7Dd4bf2CDA5926836dcB0316E19] = true; whitelist[0x2F1D71d05a2Fd7F8236C19009C82029779255A93] = true; whitelist[0x3810edDF658de0FFBEBA4d74a8ec007f04B2B6eb] = true; whitelist[0x3915A6716Ff28CfeA66F9B0f644BC4a18f916072] = true; whitelist[0x3d2FF7C764c7A10d47BaaA988347af3A9A0B1999] = true; whitelist[0x4085ADb71f055ee28f4409873bbefD85BE6e1E61] = true; whitelist[0x4124b3fe4e11d0419588abE8960aB09E3Fc5BaDA] = true; whitelist[0x41C0F1468F2731671A6Dbe5135383A28Ad47a5B7] = true; whitelist[0x42608B5217416F6F8CB2aCe1f414AF3716B76489] = true; whitelist[0x55151b934f51FE58a18862e11B069d3e1695f332] = true; whitelist[0x5F3BaDFD6E15322D9D86Af95A62e21D769FE1a3F] = true; whitelist[0x6391ab34960F779bdE2d57eF9B83B2f47d489A1E] = true; whitelist[0x6d7A28cc6D19D9707B0a2aC313F4E5Bbf05CD56a] = true; whitelist[0x74F86D244008b8bEa2C1d611EB670196530BF075] = true; whitelist[0x78Bc3ca23d278f698cd3bdd4037cEE7f18c55F4a] = true; whitelist[0x79f7E64F53CFfb93f9785a5B8F34a39654ae4590] = true; whitelist[0x84B24DC780cb6DE5bB4394d0e19EFBabEB2d4F4d] = true; whitelist[0x8C3a64AA67686D3B4699d817C13FF71B12534641] = true; whitelist[0x8d1544F93923126B7f6D84F5bCF11856FeE57Fb6] = true; whitelist[0x8f121A454ab86a3BbB90547F764cc95420FA3B97] = true; whitelist[0x9Fa89ff18068f00c9c0c82577aA8A729830Ca378] = true; whitelist[0xa8fF7872afbB6e06a912ca7a95F942CBcf69E276] = true; whitelist[0xb7F890197550BF6f87f4d1Ed92cC69A8BB32C04f] = true; whitelist[0xB9432fA0b73C8d36Ec799F48427693c3053419A5] = true; whitelist[0xC0a8e57Ba0Bc47C2453dd4Fe520e69a988786852] = true; whitelist[0xc636A5c78860Ca9Dd12457ca7af2f5d6dcb279f4] = true; whitelist[0xD845c99411c08C65db45Abc65741011ab0081b57] = true; whitelist[0xE16e9E9D309A67b3294De3B96070E21eB967017a] = true; whitelist[0xebB1220E79Bd6fe01489Ee4eb5C419485582FE8B] = true; whitelist[0xF06C2D7607a73ed521abBbdBe79C1B8Af48A6c65] = true; whitelist[0xF4D631fa4CB9322366bD5eBC25eA94dFCe1DDf09] = true; whitelist[0xf9b36a7C99A734949624f95FD3F927c4ECFEAB0D] = true; whitelist[0xFbfeC83D219fEfc04008E6b065a2BAF5F8Be7aDc] = true; whitelist[0xA86f5324129c34312187CdE5B42Fe283FC493fD8] = true; whitelist[0xccDc69E916e42a606444585aF8a3735d974Fb48A] = true; whitelist[0x04aa68FFC551b86EB2ed323FA897Cb946b2B8157] = true; whitelist[0x0AeB18Af829538D4F8feaB4d8d0a073491174969] = true; whitelist[0x42560517b33A7E68cda1640Aa47B6546BA585e30] = true; whitelist[0x4A8ce221AeEE731cd7F22EB59D7B69DE11E7a858] = true; whitelist[0x52dC5Fa1Be2428Ff782118c98291Aa812B60b4E2] = true; whitelist[0x5437500B3C72fBB66AF2C4bc6DF5f1C495D3a4bd] = true; whitelist[0x5F7754281a06F0B60cD330420Aa917e39f591C92] = true; whitelist[0x73a87E499c49BD14BeE8D12E3DAa73c97Cd9f9f2] = true; whitelist[0x7BC2eBe546aC66d37d0c933d64E060f0AD8ffaCf] = true; whitelist[0xc1b9aAEBB91399C7E7c002C3EE4b67148d4B2998] = true; whitelist[0xCAc5894367B71ED955df44c597d111647d418aF1] = true; whitelist[0x2E18F855a6b7749593Fa64479d49250Bf28018A7] = true; whitelist[0x536dCc00D8eBe2fD78E2A235dAE88322B18bbF83] = true; whitelist[0x99b0Ee8B91F0D1E7a32947df149Ad07fDaDFC8ca] = true; whitelist[0xcefBc24f9725516BDC329EDf5a300a5c03949b42] = true; whitelist[0xD7E51E919EFC08B3D8F02F86D9e4CFe3B5101958] = true; whitelist[0x2275B8be039e99F88835CE49B16285aD0e61d485] = true; whitelist[0x2C840c282dE8b08cbAfAfD488459F2fA50906888] = true; whitelist[0x2E6DE1dFebFfE1D5123e5AB342A6003f40ce71C1] = true; whitelist[0x5e75E7c69027175A16c16BA0c992b0935b3faf7E] = true; whitelist[0x61a002c7F723B8702Dc910D14e1d95a523a8FCCC] = true; whitelist[0x71bc7C03F5BEb715E40aCDB5Ab110e96E2214Cdc] = true; whitelist[0x793C7e1910F58c4c1a50448f4661D5C077214c1e] = true; whitelist[0x99C320B2C52443ec5D39CC24962a132B54260522] = true; whitelist[0x9ce16b0Ff00CEA66C954EFcD6Bc93c7bf2c06c3D] = true; whitelist[0xAae159043315daD76Ba431C970e6EE6acE1458AA] = true; whitelist[0xAE24fbe47ADB788150d9E3e7078040AbC22deD74] = true; whitelist[0xb0738A63A7E7De622661065a4B0695d046d29268] = true; whitelist[0xbEe1f7e369B3271088Ed58bF225DF13Cd96D32d5] = true; whitelist[0xDA1E0F4942Dde3bA7dAcED8fc97d978c5B930345] = true; whitelist[0xE15439FfE5e814e7502f8dA37435E77f5418d60F] = true; whitelist[0xE5463558a8241EC7bC70B202e7CB3D1465DbB124] = true; whitelist[0x0630E4A19505d253B0514fD01FDbE7e439F1A5Cb] = true; whitelist[0x0D0B3EF1487272F65681905063a35DB8CdC7d2D4] = true; whitelist[0x0DC87F37Acb9E6653991Fd365Cd92C142d07D43a] = true; whitelist[0x1d3Dd1da628E8F975523147182D47C14d537dB32] = true; whitelist[0x1DDCB237f234e1207F48624d242170F6cB8F8a7a] = true; whitelist[0x26ad010b488B67BA41b1A5C3dFEf10ba814D021A] = true; whitelist[0x31c4Eb8260e7005aAa63d8093699f236ED9bfF59] = true; whitelist[0x36e49F5Ab13fc41EB7598cDA84af9f6b92f6aD95] = true; whitelist[0x40C412E652cbcb8e381b7d69B2761820e138d89f] = true; whitelist[0x4D0852fCA6aB6f5D6cF13604611A3ee2B0b020c6] = true; whitelist[0x55D83306f7c02b4247A542a79E29A73AdA9Bb199] = true; whitelist[0x56dFFD232fc2C4f8bcd77887310cbA8076D3dD6b] = true; whitelist[0x570F1F3845a98B24EC7A82757F335838803A6cDb] = true; whitelist[0x57C9bCF0d1653B424c5F6cBB0436504Db56777fb] = true; whitelist[0x585c5598eeBf6f24982bFF282317F06A28170EB2] = true; whitelist[0x59cdc9C838B10C66B07B4D35A1aBA2f8FAb90b06] = true; whitelist[0x5bfEa1EB3FaA6eb85694BA28395f80EB8795Cf17] = true; whitelist[0x5cD0d3070E641c45766106bb1cD55fBf47095AF8] = true; whitelist[0x5D7896F73991C12Af4222748a9f3216024721618] = true; whitelist[0x5e2dbF20FC606896BBAa07E45C104Ca36Cf9Ca52] = true; whitelist[0x5f96511BA488C17879DA9425f39724D79c37d076] = true; whitelist[0x6C9486f50545AE405ea6b882bdee105A5FB78459] = true; whitelist[0x70f0E31C62bc9965c462790B6ACC6d0c655e99dE] = true; whitelist[0x739dD679224108509577652a62ab2A6150271E13] = true; whitelist[0x75a54C67330f4bb7d2Ab570Fdc410F4fc27C04de] = true; whitelist[0x75Cc9eC753070a4d1374e33aAc59619dA51F16b6] = true; whitelist[0x789F5EA765206BD040F5F86A03fcA4028E70931C] = true; whitelist[0x8a622Bc901de1fa2384d42FFA79606e446eD788F] = true; whitelist[0x8cBB211083B5B2A3210C6003703C060AC62Bebfd] = true; whitelist[0x8d83E6bDBbFabF862C9A503DA26a474aAA6C4907] = true; whitelist[0x8f123b70ab95aa2505bFe2A7B79A357FA24d53Df] = true; whitelist[0x90c01fC5F30AE6F64eB1a8565D0d5A6E98FD1feA] = true; whitelist[0x92eA6902C5023CC632e3Fd84dE7CcA6b98FE853d] = true; whitelist[0x96145139c8508Cf865efCa89e7c765eD5bf6235E] = true; whitelist[0x9902409aDd3263ebaccFeF71e3D95329623bFb30] = true; whitelist[0x9F3c44A7331Ca9DA2D3432Bcb0df91186a27E3D7] = true; whitelist[0xA8635B33E4d8d44d4468c2Fb23BE9Aff02457743] = true; whitelist[0xaAb918749E02d84EbeEcB45BC4bf7DC6770c1D6E] = true; whitelist[0xb360DDF74c9d0FB30E8D2CFFc2dA78CA85AB7b3a] = true; whitelist[0xb5619Ba9D7f67254e4C53c8bE903d951B551C9a5] = true; whitelist[0xb78F103De81747742B46bfd035764FD4734c80CD] = true; whitelist[0xB826F8dA4AcC747434Aa06cf6b18C0Fc9F84A69f] = true; whitelist[0xB84BE63f658365e94602d150b85FaB0cDC7Fc538] = true; whitelist[0xb891683fef799F0a619fb214408580f433748250] = true; whitelist[0xc479477db18101DD879Fc858932aeb2B373cb436] = true; whitelist[0xc6564E562706c83df79b6D479C2A0d412Fa18a23] = true; whitelist[0xc957775E49c99ca4a991048aD5dA79C5a5a8EB66] = true; whitelist[0xCaBfD430BaD193973fc88b84cFC22D5273Da94e5] = true; whitelist[0xcF2Eee8B0FC2e94e2C11344c5F30fdE16478339a] = true; whitelist[0xD1E1B4C6a090D92efBc683aa562142dABf0dc61d] = true; whitelist[0xD1E1B4C6a090D92efBc683aa562142dABf0dc61d] = true; whitelist[0xd813A0306FA07EC9bbF8ECAC119B130aBc9Bfb52] = true; whitelist[0xdC001A8f80FEd6F7e1b91B093e87d39ff0c39d02] = true; whitelist[0xDD47bE73FD91eCe2499c4500D0948f70E6B1c3b4] = true; whitelist[0xE10786ed6c8b7363aC502De7270CD8B9F8CD248a] = true; whitelist[0xe1E5440cc188BbA2e2Eeeb37d4fd698507dE2E41] = true; whitelist[0xE1fDd759488a5276C320AACAB12EA38Ca8c7fBdf] = true; whitelist[0xE524B912fB1f2471F3457ABe5B17Fb27ce84ab5D] = true; whitelist[0xe668569e8E4eC78a9054be071290f76FA420097d] = true; whitelist[0xe875831D33CF814Cb1EFEaB9898a680b393A6854] = true; whitelist[0xfD8BFcDb7306499f75e74187326dEd28df19f5E4] = true; whitelist[0xfDb78F8D4Db972BF2bEE69db56E1033D87654d32] = true; whitelist[0xfebDA30b5E3f47287992b9b64c3b0bae805a25e1] = true; whitelist[0xffAE3Cc0620469716356E8bad190bB53c5600d21] = true; whitelist[0xF0a63AF4C25D68F678E746d1136Abc3912757A6F] = true; whitelist[0xf706dEf6674c9fc5C543eF0834a17c0e97e45193] = true;
  whitelist[0x5C517656114e21596C373C38B782229B10CDB00b] = true; whitelist[0x7d035d8FfA4DdF40F042f32917C6059061241a6f] = true; whitelist[0x54F85eC7073ed8c12b3b38A78cb51479d4E0c0EA] = true; whitelist[0x82359081C428D0dc548202260B82ed4917669ecF] = true; whitelist[0x272e004b13438451224E38a36eF5A91B9B16e634] = true; whitelist[0x26783Ba680190553862B53727b523a00CF3BBa4E] = true; whitelist[0xc54Ac7EBE36aC18F710595AF1b711f45D0487C1e] = true; whitelist[0x90697a3b5D622E994DaE74F86a6F972fb46cB4FD] = true; whitelist[0x4d01C4F56E9e8fb98ED4E4fcAf820325c67bE6Ed] = true; whitelist[0xA4BaAa37eaA3f5Eff840f68aF934ceD5135E4782] = true; whitelist[0xF21b51505Adb20C14F07d62bf0F601992aEF10D5] = true; whitelist[0x2AE1227bF673956D0f2DB19A045E3096f6399c20] = true; whitelist[0x8CBD671A376aEF45B3eDe7Ea4a8C22a295a3C617] = true; whitelist[0xbCF35F9Ce2873658AADcB2100D75b00EE5330640] = true; whitelist[0x7057a4AD780A60Fd506bB4592858063f416599d2] = true; whitelist[0xF41EeA0Bf4edc6d381705d05166205824A30650d] = true; whitelist[0x93Bf4f77dE028F905A5dc44937D2e155646D8d49] = true; whitelist[0xcF2Eee8B0FC2e94e2C11344c5F30fdE16478339a] = true; whitelist[0x5435f1aF6067A1cf0151Bb505Bdc429E532b9B1b] = true; whitelist[0xcF23B1f68CA01cAb0D77faa5332Cd55A738e1ae9] = true; whitelist[0xDef954641494565FA21c9292Eb0FfabF763E7D18] = true; whitelist[0x4E0E3459E0DcDf451DA39f685B1953B7d345CE34] = true; whitelist[0xe9f7E6D12a17136440beD22Ab8933ff5F799b511] = true; whitelist[0x1E742b3B6EB80bEc0a1e84F3CB58913bc3C1ca3A] = true; whitelist[0x9A34B2AbE5c715126B2d3Bf9D334e00A1B06aEF8] = true; whitelist[0x548d12EE5AdBEeF06F0208AeE371EcD99ee5Af19] = true; whitelist[0x51ECC9824a76572a5f531cB60739f7A57c40276A] = true; whitelist[0x76B297179697d65D7216fd2edB9Ab7BB843B9eD7] = true; whitelist[0xF46938fb6329f8819Cd9b871a839cB0DF33d268a] = true; whitelist[0x2ACaFE2A5fc60126E2998B683BA71FCcb50A36Bd] = true; whitelist[0x362E05FB6b565AEE2dF6da5384343b6287510BC5] = true; whitelist[0x73941899af221CBAb18eD8BB03de642347948033] = true; whitelist[0xA302f5b72dA4F9097100E630B7Ef9aE68A896E74] = true; whitelist[0xA5F7cB7d419613777EEf87A2D04f85aecc88a7Ad] = true; whitelist[0xf706dEf6674c9fc5C543eF0834a17c0e97e45193] = true;  whitelist[0xe376705caAcc70a5a1b040D024C8A331fF8A66Ca] = true;  whitelist[0x9d90695B8E0CDE0d4Cdf2dD07643CD9C820ee1Cf] = true;  whitelist[0xd5dB1C7Abfe2A1Bc6bd82c21A2Cdd576E3d2462b] = true;  whitelist[0xd98d839275cf356Ec9E34A146C7EDaAa69f29022] = true;  whitelist[0xD6DF9dd48694F6F55EA4DB678cad073363863fBC] = true;  whitelist[0x42FF9Ed7d0a256c912515e5b4F0D7A5212A56b97] = true;  whitelist[0xA422492648e3e8b75ae756Dd7992Fa262E679358] = true;  whitelist[0x141f36d315F4145165c2d30261b21B6e61F52Cc8] = true;  whitelist[0x15867648EBFcEF76B07082f4a3be271996cE955E] = true;  whitelist[0xefa0A36E9648CF589f265Cb7C385059fCC213b2E] = true;  whitelist[0xe1Bb0406E38FE6e55c03f99030F5629ea9A675B8] = true;  whitelist[0xa469E51d286E627e5C2760D0689b060e9f3b2112] = true;  whitelist[0x1D9A294444830fc7Ee584ECA68BAbF5d5FFce18e] = true;  whitelist[0xd53b6ED0404aE84ed6fA8d4904B40Bd1e09BD2a4] = true;  whitelist[0x80E93D4Ae430Da4a4A66de6F25e8B2b7d36C8E61] = true;  whitelist[0x62715c036602B3C6252358E0dBACC4701252Aa4a] = true;  whitelist[0xE4c6D7f2bd9D193DA74Eb2e41aD1209219C1d81E] = true;  whitelist[0x4dcC55421c87fd4901fdF1Bd3319C7F6Eb4c76Ad] = true;  whitelist[0x78B237236A719E91aea1eE78a1Bd0513cF48965c] = true;  whitelist[0xEc6451c4A49d2A5495Db77810209715934426A2B] = true;  whitelist[0xD98FA744E31bb12d8F88aE4126Ed7B8fAC4E009E] = true;  whitelist[0x5B94a28677C05eB346b88dd964B3FB23b186346b] = true;  whitelist[0x649363A0FDfd8285D6b69710CcB42b083AB731e6] = true;  whitelist[0x057778c8FfaaAC2f2bE656cE1742F2747d807c4f] = true;  whitelist[0x028314259BA20F047bD65b752C7714202A1810e1] = true;  whitelist[0x2c4f2D587B87A68085E5660fBf6C5a4527f6FB29] = true;  whitelist[0x5d55D4155d6244922F7952a87B3FF90E465E2fac] = true;  whitelist[0x6836DA8B7D807506FB111343005e0fAb401EfED7] = true;  whitelist[0xF03cc725d979239DB5637bDc10C7b3980A4c446A] = true;  whitelist[0x0E219a7A21Fc7554E6f0eD694Da98A5753aD141d] = true;  whitelist[0x25EaE14113D4fA2ef209358019F6C2E78F0f2aBa] = true;  whitelist[0x6E619AC069D8696077266dAaEec5aB64eb009deD] = true; whitelist[0x9f687DE417937aC91C58E9c1d3038e738D7B0550] = true; whitelist[0xa32E9eC66e4661d62Dd4363A1579a7f04Bc1182B] = true; whitelist[0xDd46e88366876158D29883eF97e8EfCeB7f31957] = true; whitelist[0xA971FDf62C4346a36e6E8d4E8b9b04A30Df12Dc7] = true; whitelist[0x0d0eC51421dAe8aBc3ae198653279f9fB8D61c67] = true; whitelist[0x0AF6D8A2bF7a0708e3E3B2EC0dFbAAB9D5534d5e] = true; whitelist[0x1120e9059B2a12b57D942F8D586b8e6d78C4d28c] = true; whitelist[0x5a01feb1100f52Fc67A474A610FFE3DB549E7b7B] = true; whitelist[0x71b3EFF5e171c80A27B7Df479F43594737c83642] = true; whitelist[0x953a6f2527A9152598D820E2b857a33D1505e0E6] = true; whitelist[0x2b6f4845C20Eb4A3BF00255785711c96CE090CD3] = true; whitelist[0x2af043455Aa33bCeEd85134B9a35Cb6717b95a13] = true; whitelist[0x157434346fe2701A289D41834AF8A052143AFEB5] = true; whitelist[0x6Ed8082445E85795624db70859dF985ce86e4503] = true; whitelist[0x05be5bd318187b230F74C41C063Ac9aeE1212eF6] = true; whitelist[0xE95785E8a2185C3e9125A85879FC310976A49E3A] = true; whitelist[0x83283300b76f7Ee712D40d2751cF9061a227878E] = true; whitelist[0x2e9E9Bd26C64d70499b6F8C17ab0bb53c601978d] = true; whitelist[0x4565e398a3c9cA8FEbee295A0c94CB1E4b450D21] = true; whitelist[0x51187c2aa81E9a87320DE080948ede93A041C162] = true; whitelist[0xaD92c07db4Ca16D2Cd1fE4A36fA7a84B633ca942] = true; whitelist[0xCd11aBBC370dbCe80B81a250DF87b3226f2B1a49] = true; whitelist[0x9ad32A104c942B725EfBa82ef7f86F1208AFbCA9] = true;  whitelist[0x8d83E6bDBbFabF862C9A503DA26a474aAA6C4907] = true;  whitelist[0x99bFB0d876AB1DafD6D0a2B7c25E3e86fFAad4df] = true;  whitelist[0xF21fb2353377e60fA8A8DbFA22f1bc2EdAbA5E08] = true;  whitelist[0x3162d96F9AAb213143bD93d6d8c3d7589e5A4c1D] = true;  whitelist[0xc0fb9e6Dd8Dbf8542a930e13E23E17d2049Efa4a] = true;  whitelist[0x33BE249B512DCb6D2FC7586047ab0220397aF2d3] = true;  whitelist[0xDbdd866663855F4f3DE1a93669Bf9630176F72A7] = true;  whitelist[0x4b7d025c61632E414996843C6815E9aa962c0a02] = true;  whitelist[0x18dd0a35977F88E7aDaDE2682e3D9A585Ad3B87D] = true;  whitelist[0xB8f5fd1478F6d0b4c6C7473F749EAe9e0f60d309] = true;  whitelist[0x0A74E6dFEC50eB6A2E23Af4419C6Eb52e886F71E] = true;  whitelist[0xbDA2dfFbce4fB8933E0B3cEA42AeCa92dD54fb09] = true;  whitelist[0xC456eE074337aD909476D614fe0f0F0d1bF22C38] = true;  whitelist[0x18d074aFf48F0F101B1Cb13F7941B0bF7464A0B8] = true;  whitelist[0xf28217a9ea9b124B61F78783dEf3aF555996546b] = true;  whitelist[0x2DC8B722d06e58B10FCF835810EebF37e99f5A32] = true;  whitelist[0xE45Eac0f77576fcd6f01f7C119393e9e0214F743] = true;  whitelist[0xe5dc36Ac0f3c224D6a7e9840B02C4eD8c3587657] = true;  whitelist[0x3C74A8D0acc928B49F13D980075aeA9845AEA71c] = true;  whitelist[0x297ec58bCC731cD4a3b910e2Fd045b50Fb750147] = true;  whitelist[0x34367832d8Cf2561a03b4c5BfC387dEd2e6d936A] = true;  whitelist[0xe605a51bAE38e5F0D4c6C618D01a34a2BBBf9447] = true;  whitelist[0x7Bf18f8ACBbaA0b380859D7c16f071B8bFE5DB73] = true;  whitelist[0x642F1a5b0D3FA52528BCD2405fdE57e9afb3C254] = true;  whitelist[0x31036D78E00b1a9F523281B6dF94d6f316dDA8Aa] = true;  whitelist[0x67D3080137D899927E6cB552112Cf65b8633573a] = true;  whitelist[0xab3935F2142AF10C590506517a656bb9dcb2d948] = true; whitelist[0x93487B173Da8813316452374dB62E1Bb0CF66F15] = true; whitelist[0xB4314123401d8A5176297E3dAf2E46B56957B491] = true; whitelist[0xBC05b4B88E721BC8b144E90D6BF6E38226a22578] = true; whitelist[0x5c8Df1692E4fEc52D13220669B821Fdc26e3dC43] = true; whitelist[0xB74D9401F38F7001479cc16b567653F8ca6F5EE8] = true; whitelist[0x1dc161B0C412448FEa7F093f0F928DdcA57c3C43] = true; whitelist[0x0E003CBd2bD31C5067676B014ae0C65E97099b81] = true; whitelist[0x8C6DEA560ff0F481197735f863aA0771c416eE07] = true; whitelist[0xCE937A2D48e5BaF50230292C4192723C77Ddf989] = true; whitelist[0x65B02609A41133b254DAe5EE1722972E08084468] = true; whitelist[0x4E64C27E6F569d800d43915164f1b8b816bcd597] = true; whitelist[0xa38a453Ce05F5fFE47E993EbC38fDb2f8830f367] = true; whitelist[0xd299B9D5eDCE129FC14691e089300296d8cDF4a6] = true; whitelist[0x60D406BcdE29b0fc4397D9bc3d1FCc09a435A40f] = true; whitelist[0x73B41FAfc67fbee0Afd35EAEAba76e7468083f07] = true; whitelist[0xAA6571D1A85eBE35D739E010A1f1e3a1665Fc340] = true; whitelist[0x55D83306f7c02b4247A542a79E29A73AdA9Bb199] = true;
  }

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

  modifier callerIsUser() {require(tx.origin == msg.sender, "The caller is another contract");
    _;}

   function addToWhitelist(address[] calldata toAddAddresses) external onlyOwner {
        for (uint i = 0; i < toAddAddresses.length; i++) {whitelist[toAddAddresses[i]] = true;} }

  function getMaxSupply() view public returns(uint256){return maxSupply;}

  function whitelistMint(uint256 quantity)  public payable callerIsUser
    {
    require(whitelist[msg.sender], "NOT_IN_WHITELIST");
    require(!paused, "contract paused");    
    require(totalSupply() + quantity <= maxSupply, "reached max supply"); 
    require(numberMinted(msg.sender) + quantity <= saleConfig.AmountForWhitelist, "can not mint this many");
      _safeMint(msg.sender, quantity);
      refundIfOver(WHITELIST_PRICE);  }
    
    function mint(uint256 quantity) public payable callerIsUser {
      require(!paused, "contract paused");    
      require(totalSupply() + quantity <= maxSupply, "reached max supply");   
      require(quantity <= maxMintAmount, "can not mint this many");
      uint256 totalCost = saleConfig.Price * quantity;
     _safeMint(msg.sender, quantity);
      refundIfOver(totalCost);  }

  function refundIfOver(uint256 price) private {
    require(msg.value >= price, "Need to send more ETH.");
    if (msg.value > price) {
      payable(msg.sender).transfer(msg.value - price); } }

    function walletOfOwner(address _owner) public view returns (uint256[] memory) {
    uint256 ownerTokenCount = balanceOf(_owner);
    uint256[] memory tokenIds = new uint256[](ownerTokenCount);
    for (uint256 i; i < ownerTokenCount; i++) {tokenIds[i] = tokenOfOwnerByIndex(_owner, i);}
    return tokenIds; }

     function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
        uint256 trueId = tokenId + 1;
        if(!revealed){return placeholderTokenUri;}
        return bytes(baseTokenUri).length > 0 ? string(abi.encodePacked(baseTokenUri, trueId.toString(), ".json")) : ""; }

   function setTokenUri(string memory _baseTokenUri) external onlyOwner{
        baseTokenUri = _baseTokenUri;}

  function reveal() public onlyOwner {revealed = true;}

  function setPlaceholderTokenUri(string memory _notRevealedURI) public onlyOwner {placeholderTokenUri = _notRevealedURI;}

   function isPublicSaleOn() public view returns (bool) {return saleConfig.Price != 0; }
  
  uint256 public constant PRICE = 0.00149 ether;

  function InitInfoOfSale(uint256 price, uint256 amountForWhitelist) external onlyOwner {saleConfig = SaleConfig(price, amountForWhitelist);}

  function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {maxMintAmount = _newmaxMintAmount;}

  function setPrice(uint256 price) external onlyOwner {saleConfig.Price = price;}
    
function withdrawMoney() external onlyOwner {
    (bool success, ) = 0xF447B9ed137C405Ce908441701a8d6D5A4a1D287.call{value: address(this).balance}("");
    require(success, "Transfer failed."); }

  function pause(bool _state) public onlyOwner {paused = _state;}
  
  function numberMinted(address owner) public view returns (uint256) {return _numberMinted(owner);}

  function getOwnershipData(uint256 tokenId) external view returns (TokenOwnership memory) {return ownershipOf(tokenId);}  
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"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":"MintedQueryForZeroAddress","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"},{"inputs":[],"name":"UnableDetermineTokenOwner","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":[{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"uint256","name":"amountForWhitelist","type":"uint256"}],"name":"InitInfoOfSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WHITELIST_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"toAddAddresses","type":"address[]"}],"name":"addToWhitelist","outputs":[],"stateMutability":"nonpayable","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":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMaxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getOwnershipData","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint64","name":"startTimestamp","type":"uint64"}],"internalType":"struct ERC721A.TokenOwnership","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isPublicSaleOn","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"numberMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"placeholderTokenUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleConfig","outputs":[{"internalType":"uint256","name":"Price","type":"uint256"},{"internalType":"uint256","name":"AmountForWhitelist","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_notRevealedURI","type":"string"}],"name":"setPlaceholderTokenUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"price","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseTokenUri","type":"string"}],"name":"setTokenUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newmaxMintAmount","type":"uint256"}],"name":"setmaxMintAmount","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":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"walletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"withdrawMoney","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

67510:21973:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51996:372;;;;;;;;;;-1:-1:-1;51996:372:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;51996:372:0;;;;;;;;89185:63;;;;;;;;;;-1:-1:-1;89185:63:0;;;;;:::i;:::-;;:::i;:::-;;88192:109;;;;;;;;;;-1:-1:-1;88192:109:0;;;;;:::i;:::-;;:::i;53812:100::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;55289:204::-;;;;;;;;;;-1:-1:-1;55289:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;3272:32:1;;;3254:51;;3242:2;3227:18;55289:204:0;3108:203:1;54878:345:0;;;;;;;;;;-1:-1:-1;54878:345:0;;;;;:::i;:::-;;:::i;67825:49::-;;;;;;;;;;;;67867:7;67825:49;;;;;3899:25:1;;;3887:2;3872:18;67825:49:0;3753:177:1;50526:101:0;;;;;;;;;;-1:-1:-1;50606:13:0;;50526:101;;67607:33;;;;;;;;;;;;;;;;56146:170;;;;;;;;;;-1:-1:-1;56146:170:0;;;;;:::i;:::-;;:::i;51180:744::-;;;;;;;;;;-1:-1:-1;51180:744:0;;;;;:::i;:::-;;:::i;88493:85::-;;;;;;;;;;-1:-1:-1;88554:10:0;:16;:21;;88493:85;;56387:185;;;;;;;;;;-1:-1:-1;56387:185:0;;;;;:::i;:::-;;:::i;87472:313::-;;;;;;;;;;-1:-1:-1;87472:313:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;86339:71::-;;;;;;;;;;-1:-1:-1;86399:9:0;;86339:71;;67912:35;;;;;;;;;;;;;:::i;50704:176::-;;;;;;;;;;-1:-1:-1;50704:176:0;;;;;:::i;:::-;;:::i;67792:28::-;;;;;;;;;;-1:-1:-1;67792:28:0;;;;;;;;;;;88366:120;;;;;;;;;;-1:-1:-1;88366:120:0;;;;;:::i;:::-;;:::i;67762:25::-;;;;;;;;;;-1:-1:-1;67762:25:0;;;;;;;;53621:124;;;;;;;;;;-1:-1:-1;53621:124:0;;;;;:::i;:::-;;:::i;88638:139::-;;;;;;;;;;-1:-1:-1;88638:139:0;;;;;:::i;:::-;;:::i;52432:206::-;;;;;;;;;;-1:-1:-1;52432:206:0;;;;;:::i;:::-;;:::i;66600:103::-;;;;;;;;;;;;;:::i;88783:106::-;;;;;;;;;;-1:-1:-1;88783:106:0;;;;;:::i;:::-;;:::i;86155:178::-;;;;;;;;;;-1:-1:-1;86155:178:0;;;;;:::i;:::-;;:::i;86416:446::-;;;;;;:::i;:::-;;:::i;88586:45::-;;;;;;;;;;;;88618:13;88586:45;;65952:87;;;;;;;;;;-1:-1:-1;65998:7:0;66025:6;-1:-1:-1;;;;;66025:6:0;65952:87;;68039:28;;;;;;;;;;-1:-1:-1;68039:28:0;;;;;;;;;;;;;6143:25:1;;;6199:2;6184:18;;6177:34;;;;6116:18;68039:28:0;5969:248:1;88895:79:0;;;;;;;;;;-1:-1:-1;88895:79:0;;;;;:::i;:::-;;:::i;89359:119::-;;;;;;;;;;-1:-1:-1;89359:119:0;;;;;:::i;:::-;;:::i;:::-;;;;6454:13:1;;-1:-1:-1;;;;;6450:39:1;6432:58;;6550:4;6538:17;;;6532:24;-1:-1:-1;;;;;6528:49:1;6506:20;;;6499:79;;;;6405:18;89359:119:0;6222:362:1;53981:104:0;;;;;;;;;;;;;:::i;67645:41::-;;;;;;;;;;-1:-1:-1;67645:41:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;86874:388;;;;;;:::i;:::-;;:::i;55565:279::-;;;;;;;;;;-1:-1:-1;55565:279:0;;;;;:::i;:::-;;:::i;88307:53::-;;;;;;;;;;;;;:::i;88982:197::-;;;;;;;;;;;;;:::i;56643:308::-;;;;;;;;;;-1:-1:-1;56643:308:0;;;;;:::i;:::-;;:::i;87794:391::-;;;;;;;;;;-1:-1:-1;87794:391:0;;;;;:::i;:::-;;:::i;67725:32::-;;;;;;;;;;;;;;;;89256:97;;;;;;;;;;-1:-1:-1;89256:97:0;;;;;:::i;:::-;;:::i;55915:164::-;;;;;;;;;;-1:-1:-1;55915:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;56036:25:0;;;56012:4;56036:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;55915:164;66858:201;;;;;;;;;;-1:-1:-1;66858:201:0;;;;;:::i;:::-;;:::i;51996:372::-;52098:4;-1:-1:-1;;;;;;52135:40:0;;-1:-1:-1;;;52135:40:0;;:105;;-1:-1:-1;;;;;;;52192:48:0;;-1:-1:-1;;;52192:48:0;52135:105;:172;;;-1:-1:-1;;;;;;;52257:50:0;;-1:-1:-1;;;52257:50:0;52135:172;:225;;;-1:-1:-1;;;;;;;;;;12445:40:0;;;52324:36;52115:245;51996:372;-1:-1:-1;;51996:372:0:o;89185:63::-;65838:13;:11;:13::i;:::-;89231:6:::1;:15:::0;;-1:-1:-1;;89231:15:0::1;::::0;::::1;;::::0;;;::::1;::::0;;89185:63::o;88192:109::-;65838:13;:11;:13::i;:::-;88271:12:::1;:28;88286:13:::0;88271:12;:28:::1;:::i;:::-;;88192:109:::0;:::o;53812:100::-;53866:13;53899:5;53892:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53812:100;:::o;55289:204::-;55357:7;55382:16;55390:7;57297:13;;-1:-1:-1;57287:23:0;57206:112;55382:16;55377:64;;55407:34;;-1:-1:-1;;;55407:34:0;;;;;;;;;;;55377:64;-1:-1:-1;55461:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;55461:24:0;;55289:204::o;54878:345::-;54951:13;54967:24;54983:7;54967:15;:24::i;:::-;54951:40;;55012:5;-1:-1:-1;;;;;55006:11:0;:2;-1:-1:-1;;;;;55006:11:0;;55002:48;;55026:24;;-1:-1:-1;;;55026:24:0;;;;;;;;;;;55002:48;47962:10;-1:-1:-1;;;;;55067:21:0;;;;;;:63;;-1:-1:-1;55093:37:0;55110:5;47962:10;55915:164;:::i;55093:37::-;55092:38;55067:63;55063:111;;;55139:35;;-1:-1:-1;;;55139:35:0;;;;;;;;;;;55063:111;55187:28;55196:2;55200:7;55209:5;55187:8;:28::i;:::-;54940:283;54878:345;;:::o;56146:170::-;56280:28;56290:4;56296:2;56300:7;56280:9;:28::i;51180:744::-;51289:7;51324:16;51334:5;51324:9;:16::i;:::-;51316:5;:24;51308:71;;;;-1:-1:-1;;;51308:71:0;;10576:2:1;51308:71:0;;;10558:21:1;10615:2;10595:18;;;10588:30;10654:34;10634:18;;;10627:62;-1:-1:-1;;;10705:18:1;;;10698:32;10747:19;;51308:71:0;;;;;;;;;51386:22;51411:13;50606;;;50526:101;51411:13;51386:38;;51431:19;51461:25;51511:9;51506:350;51530:14;51526:1;:18;51506:350;;;51560:31;51594:14;;;:11;:14;;;;;;;;;51560:48;;;;;;;;;-1:-1:-1;;;;;51560:48:0;;;;;-1:-1:-1;;;51560:48:0;;;-1:-1:-1;;;;;51560:48:0;;;;;;;;51621:28;51617:89;;51682:14;;;-1:-1:-1;51617:89:0;51739:5;-1:-1:-1;;;;;51718:26:0;:17;-1:-1:-1;;;;;51718:26:0;;51714:135;;51776:5;51761:11;:20;51757:59;;-1:-1:-1;51803:1:0;-1:-1:-1;51796:8:0;;-1:-1:-1;;;51796:8:0;51757:59;51826:13;;;;:::i;:::-;;;;51714:135;-1:-1:-1;51546:3:0;;;;:::i;:::-;;;;51506:350;;;-1:-1:-1;51862:56:0;;-1:-1:-1;;;51862:56:0;;11251:2:1;51862:56:0;;;11233:21:1;11290:2;11270:18;;;11263:30;11329:34;11309:18;;;11302:62;-1:-1:-1;;;11380:18:1;;;11373:44;11434:19;;51862:56:0;11049:410:1;56387:185:0;56525:39;56542:4;56548:2;56552:7;56525:39;;;;;;;;;;;;:16;:39::i;87472:313::-;87532:16;87557:23;87583:17;87593:6;87583:9;:17::i;:::-;87557:43;;87607:25;87649:15;-1:-1:-1;;;;;87635:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;87635:30:0;;87607:58;;87677:9;87672:89;87692:15;87688:1;:19;87672:89;;;87729:30;87749:6;87757:1;87729:19;:30::i;:::-;87715:8;87724:1;87715:11;;;;;;;;:::i;:::-;;;;;;;;;;:44;87709:3;;;;:::i;:::-;;;;87672:89;;;-1:-1:-1;87774:8:0;87472:313;-1:-1:-1;;;87472:313:0:o;67912:35::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;50704:176::-;50771:7;50804:13;50606;;;50526:101;50804:13;50795:5;:22;50791:58;;50826:23;;-1:-1:-1;;;50826:23:0;;;;;;;;;;;50791:58;-1:-1:-1;50867:5:0;50704:176::o;88366:120::-;65838:13;:11;:13::i;:::-;88447:19:::1;:37;88469:15:::0;88447:19;:37:::1;:::i;53621:124::-:0;53685:7;53712:20;53724:7;53712:11;:20::i;:::-;:25;;53621:124;-1:-1:-1;;53621:124:0:o;88638:139::-;65838:13;:11;:13::i;:::-;88738:37:::1;::::0;;;;::::1;::::0;;;;;;::::1;;::::0;;;88725:10:::1;:50:::0;;;;;;88638:139::o;52432:206::-;52496:7;-1:-1:-1;;;;;52520:19:0;;52516:60;;52548:28;;-1:-1:-1;;;52548:28:0;;;;;;;;;;;52516:60;-1:-1:-1;;;;;;52602:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;52602:27:0;;52432:206::o;66600:103::-;65838:13;:11;:13::i;:::-;66665:30:::1;66692:1;66665:18;:30::i;:::-;66600:103::o:0;88783:106::-;65838:13;:11;:13::i;:::-;88854::::1;:33:::0;88783:106::o;86155:178::-;65838:13;:11;:13::i;:::-;86249:6:::1;86244:87;86261:25:::0;;::::1;86244:87;;;86325:4;86294:9;:28;86304:14;;86319:1;86304:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;86294:28:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;86294:28:0;:35;;-1:-1:-1;;86294:35:0::1;::::0;::::1;;::::0;;;::::1;::::0;;86288:3;::::1;::::0;::::1;:::i;:::-;;;;86244:87;;86416:446:::0;86080:9;86093:10;86080:23;86072:66;;;;-1:-1:-1;;;86072:66:0;;11798:2:1;86072:66:0;;;11780:21:1;11837:2;11817:18;;;11810:30;11876:32;11856:18;;;11849:60;11926:18;;86072:66:0;11596:354:1;86072:66:0;86516:10:::1;86506:21;::::0;;;:9:::1;:21;::::0;;;;;::::1;;86498:50;;;::::0;-1:-1:-1;;;86498:50:0;;12157:2:1;86498:50:0::1;::::0;::::1;12139:21:1::0;12196:2;12176:18;;;12169:30;-1:-1:-1;;;12215:18:1;;;12208:46;12271:18;;86498:50:0::1;11955:340:1::0;86498:50:0::1;86564:6;::::0;::::1;;86563:7;86555:35;;;::::0;-1:-1:-1;;;86555:35:0;;12502:2:1;86555:35:0::1;::::0;::::1;12484:21:1::0;12541:2;12521:18;;;12514:30;-1:-1:-1;;;12560:18:1;;;12553:45;12615:18;;86555:35:0::1;12300:339:1::0;86555:35:0::1;86637:9;;86625:8;86609:13;50606::::0;;;50526:101;86609:13:::1;:24;;;;:::i;:::-;:37;;86601:68;;;::::0;-1:-1:-1;;;86601:68:0;;12976:2:1;86601:68:0::1;::::0;::::1;12958:21:1::0;13015:2;12995:18;;;12988:30;-1:-1:-1;;;13034:18:1;;;13027:48;13092:18;;86601:68:0::1;12774:342:1::0;86601:68:0::1;86724:29:::0;;86712:8;86685:24:::1;86698:10;86685:12;:24::i;:::-;:35;;;;:::i;:::-;:68;;86677:103;;;::::0;-1:-1:-1;;;86677:103:0;;13323:2:1;86677:103:0::1;::::0;::::1;13305:21:1::0;13362:2;13342:18;;;13335:30;-1:-1:-1;;;13381:18:1;;;13374:52;13443:18;;86677:103:0::1;13121:346:1::0;86677:103:0::1;86789:31;86799:10;86811:8;86789:9;:31::i;:::-;86829:29;67867:7;86829:12;:29::i;:::-;86416:446:::0;:::o;88895:79::-;65838:13;:11;:13::i;:::-;88948:10:::1;:24:::0;88895:79::o;89359:119::-;-1:-1:-1;;;;;;;;;;;;;;;;;89456:20:0;89468:7;89456:11;:20::i;53981:104::-;54037:13;54070:7;54063:14;;;;;:::i;86874:388::-;86080:9;86093:10;86080:23;86072:66;;;;-1:-1:-1;;;86072:66:0;;11798:2:1;86072:66:0;;;11780:21:1;11837:2;11817:18;;;11810:30;11876:32;11856:18;;;11849:60;11926:18;;86072:66:0;11596:354:1;86072:66:0;86952:6:::1;::::0;::::1;;86951:7;86943:35;;;::::0;-1:-1:-1;;;86943:35:0;;12502:2:1;86943:35:0::1;::::0;::::1;12484:21:1::0;12541:2;12521:18;;;12514:30;-1:-1:-1;;;12560:18:1;;;12553:45;12615:18;;86943:35:0::1;12300:339:1::0;86943:35:0::1;87027:9;;87015:8;86999:13;50606::::0;;;50526:101;86999:13:::1;:24;;;;:::i;:::-;:37;;86991:68;;;::::0;-1:-1:-1;;;86991:68:0;;12976:2:1;86991:68:0::1;::::0;::::1;12958:21:1::0;13015:2;12995:18;;;12988:30;-1:-1:-1;;;13034:18:1;;;13027:48;13092:18;;86991:68:0::1;12774:342:1::0;86991:68:0::1;87091:13;;87079:8;:25;;87071:60;;;::::0;-1:-1:-1;;;87071:60:0;;13323:2:1;87071:60:0::1;::::0;::::1;13305:21:1::0;13362:2;13342:18;;;13335:30;-1:-1:-1;;;13381:18:1;;;13374:52;13443:18;;87071:60:0::1;13121:346:1::0;87071:60:0::1;87160:10;:16:::0;87140:17:::1;::::0;87160:27:::1;::::0;87179:8;;87160:27:::1;:::i;:::-;87140:47;;87195:31;87205:10;87217:8;87195:9;:31::i;:::-;87235:23;87248:9;87235:12;:23::i;55565:279::-:0;47962:10;-1:-1:-1;;;;;55656:24:0;;;55652:54;;55689:17;;-1:-1:-1;;;55689:17:0;;;;;;;;;;;55652:54;47962:10;55719:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;55719:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;55719:53:0;;;;;;;;;;55788:48;;540:41:1;;;55719:42:0;;47962:10;55788:48;;513:18:1;55788:48:0;;;;;;;55565:279;;:::o;88307:53::-;65838:13;:11;:13::i;:::-;88343:8:::1;:15:::0;;-1:-1:-1;;88343:15:0::1;;;::::0;;88307:53::o;88982:197::-;65838:13;:11;:13::i;:::-;89052:81:::1;::::0;89034:12:::1;::::0;89052:42:::1;::::0;89107:21:::1;::::0;89034:12;89052:81;89034:12;89052:81;89107:21;89052:42;:81:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;89033:100;;;89148:7;89140:36;;;::::0;-1:-1:-1;;;89140:36:0;;14057:2:1;89140:36:0::1;::::0;::::1;14039:21:1::0;14096:2;14076:18;;;14069:30;-1:-1:-1;;;14115:18:1;;;14108:46;14171:18;;89140:36:0::1;13855:340:1::0;56643:308:0;56802:28;56812:4;56818:2;56822:7;56802:9;:28::i;:::-;56846:48;56869:4;56875:2;56879:7;56888:5;56846:22;:48::i;:::-;56841:102;;56903:40;;-1:-1:-1;;;56903:40:0;;;;;;;;;;;56841:102;56643:308;;;;:::o;87794:391::-;87867:13;87901:16;87909:7;57297:13;;-1:-1:-1;57287:23:0;57206:112;87901:16;87893:76;;;;-1:-1:-1;;;87893:76:0;;14402:2:1;87893:76:0;;;14384:21:1;14441:2;14421:18;;;14414:30;14480:34;14460:18;;;14453:62;-1:-1:-1;;;14531:18:1;;;14524:45;14586:19;;87893:76:0;14200:411:1;87893:76:0;87980:14;87997:11;:7;88007:1;87997:11;:::i;:::-;88023:8;;87980:28;;-1:-1:-1;88023:8:0;;;;;88019:42;;88040:19;88033:26;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;87794:391;;;:::o;88019:42::-;88107:1;88084:12;88078:26;;;;;:::i;:::-;;;:30;:104;;;;;;;;;;;;;;;;;88135:12;88149:17;:6;:15;:17::i;:::-;88118:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;88078:104;88071:111;87794:391;-1:-1:-1;;;87794:391:0:o;89256:97::-;89314:7;89331:20;89345:5;89331:13;:20::i;66858:201::-;65838:13;:11;:13::i;:::-;-1:-1:-1;;;;;66947:22:0;::::1;66939:73;;;::::0;-1:-1:-1;;;66939:73:0;;16010:2:1;66939:73:0::1;::::0;::::1;15992:21:1::0;16049:2;16029:18;;;16022:30;16088:34;16068:18;;;16061:62;-1:-1:-1;;;16139:18:1;;;16132:36;16185:19;;66939:73:0::1;15808:402:1::0;66939:73:0::1;67023:28;67042:8;67023:18;:28::i;66117:132::-:0;65998:7;66025:6;-1:-1:-1;;;;;66025:6:0;47962:10;66181:23;66173:68;;;;-1:-1:-1;;;66173:68:0;;16417:2:1;66173:68:0;;;16399:21:1;;;16436:18;;;16429:30;16495:34;16475:18;;;16468:62;16547:18;;66173:68:0;16215:356:1;61969:196:0;62084:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;62084:29:0;-1:-1:-1;;;;;62084:29:0;;;;;;;;;62129:28;;62084:24;;62129:28;;;;;;;61969:196;;;:::o;59889:1962::-;60004:35;60042:20;60054:7;60042:11;:20::i;:::-;60117:18;;60004:58;;-1:-1:-1;60075:22:0;;-1:-1:-1;;;;;60101:34:0;47962:10;-1:-1:-1;;;;;60101:34:0;;:87;;;-1:-1:-1;47962:10:0;60152:20;60164:7;60152:11;:20::i;:::-;-1:-1:-1;;;;;60152:36:0;;60101:87;:154;;;-1:-1:-1;60222:18:0;;60205:50;;47962:10;55915:164;:::i;60205:50::-;60075:181;;60274:17;60269:66;;60300:35;;-1:-1:-1;;;60300:35:0;;;;;;;;;;;60269:66;60372:4;-1:-1:-1;;;;;60350:26:0;:13;:18;;;-1:-1:-1;;;;;60350:26:0;;60346:67;;60385:28;;-1:-1:-1;;;60385:28:0;;;;;;;;;;;60346:67;-1:-1:-1;;;;;60428:16:0;;60424:52;;60453:23;;-1:-1:-1;;;60453:23:0;;;;;;;;;;;60424:52;60597:49;60614:1;60618:7;60627:13;:18;;;60597:8;:49::i;:::-;-1:-1:-1;;;;;60942:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;;;;;60942:31:0;;;-1:-1:-1;;;;;60942:31:0;;;-1:-1:-1;;60942:31:0;;;;;;;60988:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;60988:29:0;;;;;;;;;;;;;61034:20;;;:11;:20;;;;;;:30;;-1:-1:-1;;;;;;61079:61:0;;;;-1:-1:-1;;;61124:15:0;-1:-1:-1;;;;;61079:61:0;;;;;61414:11;;;61444:24;;;;;:29;61414:11;;61444:29;61440:295;;61512:20;61520:11;57297:13;;-1:-1:-1;57287:23:0;57206:112;61512:20;61508:212;;;61589:18;;;61557:24;;;:11;:24;;;;;;;;:50;;61672:28;;;;-1:-1:-1;;;;;61630:70:0;-1:-1:-1;;;61630:70:0;-1:-1:-1;;;;;;61630:70:0;;;-1:-1:-1;;;;;61557:50:0;;;61630:70;;;;;;;61508:212;60917:829;61782:7;61778:2;-1:-1:-1;;;;;61763:27:0;61772:4;-1:-1:-1;;;;;61763:27:0;;;;;;;;;;;61801:42;59993:1858;;59889:1962;;;:::o;53055:504::-;-1:-1:-1;;;;;;;;;;;;;;;;;53155:16:0;53163:7;57297:13;;-1:-1:-1;57287:23:0;57206:112;53155:16;53150:61;;53180:31;;-1:-1:-1;;;53180:31:0;;;;;;;;;;;53150:61;53269:7;53249:245;53316:31;53350:17;;;:11;:17;;;;;;;;;53316:51;;;;;;;;;-1:-1:-1;;;;;53316:51:0;;;;;-1:-1:-1;;;53316:51:0;;;-1:-1:-1;;;;;53316:51:0;;;;;;;;53390:28;53386:93;;53450:9;53055:504;-1:-1:-1;;;53055:504:0:o;53386:93::-;-1:-1:-1;;;53289:6:0;53249:245;;67219:191;67293:16;67312:6;;-1:-1:-1;;;;;67329:17:0;;;-1:-1:-1;;;;;;67329:17:0;;;;;;67362:40;;67312:6;;;;;;;67362:40;;67293:16;67362:40;67282:128;67219:191;:::o;57326:104::-;57395:27;57405:2;57409:8;57395:27;;;;;;;;;;;;:9;:27::i;87268:196::-;87341:5;87328:9;:18;;87320:53;;;;-1:-1:-1;;;87320:53:0;;16778:2:1;87320:53:0;;;16760:21:1;16817:2;16797:18;;;16790:30;-1:-1:-1;;;16836:18:1;;;16829:52;16898:18;;87320:53:0;16576:346:1;87320:53:0;87396:5;87384:9;:17;87380:82;;;87420:10;87412:47;87441:17;87453:5;87441:9;:17;:::i;:::-;87412:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62730:765;62885:4;-1:-1:-1;;;;;62906:13:0;;1600:19;:23;62902:586;;62942:72;;-1:-1:-1;;;62942:72:0;;-1:-1:-1;;;;;62942:36:0;;;;;:72;;47962:10;;62993:4;;62999:7;;63008:5;;62942:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62942:72:0;;;;;;;;-1:-1:-1;;62942:72:0;;;;;;;;;;;;:::i;:::-;;;62938:495;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63188:6;:13;63205:1;63188:18;63184:234;;63215:40;;-1:-1:-1;;;63215:40:0;;;;;;;;;;;63184:234;63368:6;63362:13;63353:6;63349:2;63345:15;63338:38;62938:495;-1:-1:-1;;;;;;63065:55:0;-1:-1:-1;;;63065:55:0;;-1:-1:-1;63058:62:0;;62902:586;-1:-1:-1;63472:4:0;62902:586;62730:765;;;;;;:::o;42363:716::-;42419:13;42470:14;42487:17;42498:5;42487:10;:17::i;:::-;42507:1;42487:21;42470:38;;42523:20;42557:6;-1:-1:-1;;;;;42546:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42546:18:0;-1:-1:-1;42523:41:0;-1:-1:-1;42688:28:0;;;42704:2;42688:28;42745:288;-1:-1:-1;;42777:5:0;-1:-1:-1;;;42914:2:0;42903:14;;42898:30;42777:5;42885:44;42975:2;42966:11;;;-1:-1:-1;42996:21:0;42745:288;42996:21;-1:-1:-1;43054:6:0;42363:716;-1:-1:-1;;;42363:716:0:o;52646:207::-;52707:7;-1:-1:-1;;;;;52731:19:0;;52727:59;;52759:27;;-1:-1:-1;;;52759:27:0;;;;;;;;;;;52727:59;-1:-1:-1;;;;;;52812:19:0;;;;;:12;:19;;;;;:32;-1:-1:-1;;;52812:32:0;;-1:-1:-1;;;;;52812:32:0;;52646:207::o;57793:163::-;57916:32;57922:2;57926:8;57936:5;57943:4;57916:5;:32::i;39229:922::-;39282:7;;-1:-1:-1;;;39360:15:0;;39356:102;;-1:-1:-1;;;39396:15:0;;;-1:-1:-1;39440:2:0;39430:12;39356:102;39485:6;39476:5;:15;39472:102;;39521:6;39512:15;;;-1:-1:-1;39556:2:0;39546:12;39472:102;39601:6;39592:5;:15;39588:102;;39637:6;39628:15;;;-1:-1:-1;39672:2:0;39662:12;39588:102;39717:5;39708;:14;39704:99;;39752:5;39743:14;;;-1:-1:-1;39786:1:0;39776:11;39704:99;39830:5;39821;:14;39817:99;;39865:5;39856:14;;;-1:-1:-1;39899:1:0;39889:11;39817:99;39943:5;39934;:14;39930:99;;39978:5;39969:14;;;-1:-1:-1;40012:1:0;40002:11;39930:99;40056:5;40047;:14;40043:66;;40092:1;40082:11;40137:6;39229:922;-1:-1:-1;;39229:922:0:o;58215:1420::-;58377:13;;-1:-1:-1;;;;;58405:16:0;;58401:48;;58430:19;;-1:-1:-1;;;58430:19:0;;;;;;;;;;;58401:48;58464:8;58476:1;58464:13;58460:44;;58486:18;;-1:-1:-1;;;58486:18:0;;;;;;;;;;;58460:44;-1:-1:-1;;;;;58857:16:0;;;;;;:12;:16;;;;;;;;:45;;-1:-1:-1;;;;;;;;;58857:45:0;;-1:-1:-1;;;;;58857:45:0;;;;;;;;;;58917:50;;;;;;;;;;;;;;58984:25;;;:11;:25;;;;;:35;;-1:-1:-1;;;;;;59034:66:0;;;;-1:-1:-1;;;59084:15:0;-1:-1:-1;;;;;59034:66:0;;;;;;58984:25;;59169:330;59189:8;59185:1;:12;59169:330;;;59228:38;;59253:12;;-1:-1:-1;;;;;59228:38:0;;;59245:1;;59228:38;;59245:1;;59228:38;59289:4;:68;;;;;59298:59;59329:1;59333:2;59337:12;59351:5;59298:22;:59::i;:::-;59297:60;59289:68;59285:164;;;59389:40;;-1:-1:-1;;;59389:40:0;;;;;;;;;;;59285:164;59469:14;;;;;59199:3;59169:330;;;-1:-1:-1;59515:13:0;:28;59567:60;56643:308;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:160::-;657:20;;713:13;;706:21;696:32;;686:60;;742:1;739;732:12;686:60;592:160;;;:::o;757:180::-;813:6;866:2;854:9;845:7;841:23;837:32;834:52;;;882:1;879;872:12;834:52;905:26;921:9;905:26;:::i;942:127::-;1003:10;998:3;994:20;991:1;984:31;1034:4;1031:1;1024:15;1058:4;1055:1;1048:15;1074:632;1139:5;-1:-1:-1;;;;;1210:2:1;1202:6;1199:14;1196:40;;;1216:18;;:::i;:::-;1291:2;1285:9;1259:2;1345:15;;-1:-1:-1;;1341:24:1;;;1367:2;1337:33;1333:42;1321:55;;;1391:18;;;1411:22;;;1388:46;1385:72;;;1437:18;;:::i;:::-;1477:10;1473:2;1466:22;1506:6;1497:15;;1536:6;1528;1521:22;1576:3;1567:6;1562:3;1558:16;1555:25;1552:45;;;1593:1;1590;1583:12;1552:45;1643:6;1638:3;1631:4;1623:6;1619:17;1606:44;1698:1;1691:4;1682:6;1674;1670:19;1666:30;1659:41;;;;1074:632;;;;;:::o;1711:451::-;1780:6;1833:2;1821:9;1812:7;1808:23;1804:32;1801:52;;;1849:1;1846;1839:12;1801:52;1889:9;1876:23;-1:-1:-1;;;;;1914:6:1;1911:30;1908:50;;;1954:1;1951;1944:12;1908:50;1977:22;;2030:4;2022:13;;2018:27;-1:-1:-1;2008:55:1;;2059:1;2056;2049:12;2008:55;2082:74;2148:7;2143:2;2130:16;2125:2;2121;2117:11;2082:74;:::i;2167:250::-;2252:1;2262:113;2276:6;2273:1;2270:13;2262:113;;;2352:11;;;2346:18;2333:11;;;2326:39;2298:2;2291:10;2262:113;;;-1:-1:-1;;2409:1:1;2391:16;;2384:27;2167:250::o;2422:271::-;2464:3;2502:5;2496:12;2529:6;2524:3;2517:19;2545:76;2614:6;2607:4;2602:3;2598:14;2591:4;2584:5;2580:16;2545:76;:::i;:::-;2675:2;2654:15;-1:-1:-1;;2650:29:1;2641:39;;;;2682:4;2637:50;;2422:271;-1:-1:-1;;2422:271:1:o;2698:220::-;2847:2;2836:9;2829:21;2810:4;2867:45;2908:2;2897:9;2893:18;2885:6;2867:45;:::i;2923:180::-;2982:6;3035:2;3023:9;3014:7;3010:23;3006:32;3003:52;;;3051:1;3048;3041:12;3003:52;-1:-1:-1;3074:23:1;;2923:180;-1:-1:-1;2923:180:1:o;3316:173::-;3384:20;;-1:-1:-1;;;;;3433:31:1;;3423:42;;3413:70;;3479:1;3476;3469:12;3494:254;3562:6;3570;3623:2;3611:9;3602:7;3598:23;3594:32;3591:52;;;3639:1;3636;3629:12;3591:52;3662:29;3681:9;3662:29;:::i;:::-;3652:39;3738:2;3723:18;;;;3710:32;;-1:-1:-1;;;3494:254:1:o;3935:328::-;4012:6;4020;4028;4081:2;4069:9;4060:7;4056:23;4052:32;4049:52;;;4097:1;4094;4087:12;4049:52;4120:29;4139:9;4120:29;:::i;:::-;4110:39;;4168:38;4202:2;4191:9;4187:18;4168:38;:::i;:::-;4158:48;;4253:2;4242:9;4238:18;4225:32;4215:42;;3935:328;;;;;:::o;4268:186::-;4327:6;4380:2;4368:9;4359:7;4355:23;4351:32;4348:52;;;4396:1;4393;4386:12;4348:52;4419:29;4438:9;4419:29;:::i;4459:632::-;4630:2;4682:21;;;4752:13;;4655:18;;;4774:22;;;4601:4;;4630:2;4853:15;;;;4827:2;4812:18;;;4601:4;4896:169;4910:6;4907:1;4904:13;4896:169;;;4971:13;;4959:26;;5040:15;;;;5005:12;;;;4932:1;4925:9;4896:169;;;-1:-1:-1;5082:3:1;;4459:632;-1:-1:-1;;;;;;4459:632:1:o;5096:248::-;5164:6;5172;5225:2;5213:9;5204:7;5200:23;5196:32;5193:52;;;5241:1;5238;5231:12;5193:52;-1:-1:-1;;5264:23:1;;;5334:2;5319:18;;;5306:32;;-1:-1:-1;5096:248:1:o;5349:615::-;5435:6;5443;5496:2;5484:9;5475:7;5471:23;5467:32;5464:52;;;5512:1;5509;5502:12;5464:52;5552:9;5539:23;-1:-1:-1;;;;;5622:2:1;5614:6;5611:14;5608:34;;;5638:1;5635;5628:12;5608:34;5676:6;5665:9;5661:22;5651:32;;5721:7;5714:4;5710:2;5706:13;5702:27;5692:55;;5743:1;5740;5733:12;5692:55;5783:2;5770:16;5809:2;5801:6;5798:14;5795:34;;;5825:1;5822;5815:12;5795:34;5878:7;5873:2;5863:6;5860:1;5856:14;5852:2;5848:23;5844:32;5841:45;5838:65;;;5899:1;5896;5889:12;5838:65;5930:2;5922:11;;;;;5952:6;;-1:-1:-1;5349:615:1;;-1:-1:-1;;;;5349:615:1:o;6589:254::-;6654:6;6662;6715:2;6703:9;6694:7;6690:23;6686:32;6683:52;;;6731:1;6728;6721:12;6683:52;6754:29;6773:9;6754:29;:::i;:::-;6744:39;;6802:35;6833:2;6822:9;6818:18;6802:35;:::i;:::-;6792:45;;6589:254;;;;;:::o;6848:667::-;6943:6;6951;6959;6967;7020:3;7008:9;6999:7;6995:23;6991:33;6988:53;;;7037:1;7034;7027:12;6988:53;7060:29;7079:9;7060:29;:::i;:::-;7050:39;;7108:38;7142:2;7131:9;7127:18;7108:38;:::i;:::-;7098:48;;7193:2;7182:9;7178:18;7165:32;7155:42;;7248:2;7237:9;7233:18;7220:32;-1:-1:-1;;;;;7267:6:1;7264:30;7261:50;;;7307:1;7304;7297:12;7261:50;7330:22;;7383:4;7375:13;;7371:27;-1:-1:-1;7361:55:1;;7412:1;7409;7402:12;7361:55;7435:74;7501:7;7496:2;7483:16;7478:2;7474;7470:11;7435:74;:::i;:::-;7425:84;;;6848:667;;;;;;;:::o;7520:260::-;7588:6;7596;7649:2;7637:9;7628:7;7624:23;7620:32;7617:52;;;7665:1;7662;7655:12;7617:52;7688:29;7707:9;7688:29;:::i;:::-;7678:39;;7736:38;7770:2;7759:9;7755:18;7736:38;:::i;7785:380::-;7864:1;7860:12;;;;7907;;;7928:61;;7982:4;7974:6;7970:17;7960:27;;7928:61;8035:2;8027:6;8024:14;8004:18;8001:38;7998:161;;8081:10;8076:3;8072:20;8069:1;8062:31;8116:4;8113:1;8106:15;8144:4;8141:1;8134:15;7998:161;;7785:380;;;:::o;8296:545::-;8398:2;8393:3;8390:11;8387:448;;;8434:1;8459:5;8455:2;8448:17;8504:4;8500:2;8490:19;8574:2;8562:10;8558:19;8555:1;8551:27;8545:4;8541:38;8610:4;8598:10;8595:20;8592:47;;;-1:-1:-1;8633:4:1;8592:47;8688:2;8683:3;8679:12;8676:1;8672:20;8666:4;8662:31;8652:41;;8743:82;8761:2;8754:5;8751:13;8743:82;;;8806:17;;;8787:1;8776:13;8743:82;;;8747:3;;;8296:545;;;:::o;9017:1352::-;9143:3;9137:10;-1:-1:-1;;;;;9162:6:1;9159:30;9156:56;;;9192:18;;:::i;:::-;9221:97;9311:6;9271:38;9303:4;9297:11;9271:38;:::i;:::-;9265:4;9221:97;:::i;:::-;9373:4;;9437:2;9426:14;;9454:1;9449:663;;;;10156:1;10173:6;10170:89;;;-1:-1:-1;10225:19:1;;;10219:26;10170:89;-1:-1:-1;;8974:1:1;8970:11;;;8966:24;8962:29;8952:40;8998:1;8994:11;;;8949:57;10272:81;;9419:944;;9449:663;8243:1;8236:14;;;8280:4;8267:18;;-1:-1:-1;;9485:20:1;;;9603:236;9617:7;9614:1;9611:14;9603:236;;;9706:19;;;9700:26;9685:42;;9798:27;;;;9766:1;9754:14;;;;9633:19;;9603:236;;;9607:3;9867:6;9858:7;9855:19;9852:201;;;9928:19;;;9922:26;-1:-1:-1;;10011:1:1;10007:14;;;10023:3;10003:24;9999:37;9995:42;9980:58;9965:74;;9852:201;-1:-1:-1;;;;;10099:1:1;10083:14;;;10079:22;10066:36;;-1:-1:-1;9017:1352:1:o;10777:127::-;10838:10;10833:3;10829:20;10826:1;10819:31;10869:4;10866:1;10859:15;10893:4;10890:1;10883:15;10909:135;10948:3;10969:17;;;10966:43;;10989:18;;:::i;:::-;-1:-1:-1;11036:1:1;11025:13;;10909:135::o;11464:127::-;11525:10;11520:3;11516:20;11513:1;11506:31;11556:4;11553:1;11546:15;11580:4;11577:1;11570:15;12644:125;12709:9;;;12730:10;;;12727:36;;;12743:18;;:::i;13472:168::-;13545:9;;;13576;;13593:15;;;13587:22;;13573:37;13563:71;;13614:18;;:::i;14616:1187::-;14893:3;14922:1;14955:6;14949:13;14985:36;15011:9;14985:36;:::i;:::-;15040:1;15057:18;;;15084:133;;;;15231:1;15226:356;;;;15050:532;;15084:133;-1:-1:-1;;15117:24:1;;15105:37;;15190:14;;15183:22;15171:35;;15162:45;;;-1:-1:-1;15084:133:1;;15226:356;15257:6;15254:1;15247:17;15287:4;15332:2;15329:1;15319:16;15357:1;15371:165;15385:6;15382:1;15379:13;15371:165;;;15463:14;;15450:11;;;15443:35;15506:16;;;;15400:10;;15371:165;;;15375:3;;;15565:6;15560:3;15556:16;15549:23;;15050:532;;;;;15613:6;15607:13;15629:68;15688:8;15683:3;15676:4;15668:6;15664:17;15629:68;:::i;:::-;-1:-1:-1;;;15719:18:1;;15746:22;;;15795:1;15784:13;;14616:1187;-1:-1:-1;;;;14616:1187:1:o;16927:128::-;16994:9;;;17015:11;;;17012:37;;;17029:18;;:::i;17060:489::-;-1:-1:-1;;;;;17329:15:1;;;17311:34;;17381:15;;17376:2;17361:18;;17354:43;17428:2;17413:18;;17406:34;;;17476:3;17471:2;17456:18;;17449:31;;;17254:4;;17497:46;;17523:19;;17515:6;17497:46;:::i;:::-;17489:54;17060:489;-1:-1:-1;;;;;;17060:489:1:o;17554:249::-;17623:6;17676:2;17664:9;17655:7;17651:23;17647:32;17644:52;;;17692:1;17689;17682:12;17644:52;17724:9;17718:16;17743:30;17767:5;17743:30;:::i

Swarm Source

ipfs://426ccdbfeadf09101887d28621540c86df88692e8366cd715d990edbdfd272a9

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