Token 3D Birds

 

Overview [ERC-721]

Max Total Supply:
10,000 3DB

Holders:
4,555

Transfers:
-

 
Loading
[ Download CSV Export  ] 
Loading
[ Download CSV Export  ] 
Loading

Click here to update the token information / general information
# Exchange Pair Price  24H Volume % Volume
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
Birds3D

Compiler Version
v0.8.9+commit.e5eed63a

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2022-07-06
*/

// SPDX-License-Identifier: MIT

/*
██████╗░██████╗░  ██████╗░██╗██████╗░██████╗░░██████╗
╚════██╗██╔══██╗  ██╔══██╗██║██╔══██╗██╔══██╗██╔════╝
░█████╔╝██║░░██║  ██████╦╝██║██████╔╝██║░░██║╚█████╗░
░╚═══██╗██║░░██║  ██╔══██╗██║██╔══██╗██║░░██║░╚═══██╗
██████╔╝██████╔╝  ██████╦╝██║██║░░██║██████╔╝██████╔╝
╚═════╝░╚═════╝░  ╚═════╝░╚═╝╚═╝░░╚═╝╚═════╝░╚═════╝░
*/

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


// OpenZeppelin Contracts v4.4.1 (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() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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


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

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_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) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

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

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

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

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

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


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

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 *
 * 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.
 */
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 proved to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * _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}
     *
     * _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 the sibling nodes in `proof`,
     * consuming from one or the other at each step according to the instructions given by
     * `proofFlags`.
     *
     * _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}
     *
     * _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/Context.sol


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

pragma solidity ^0.8.0;

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

// File: erc721a/contracts/IERC721A.sol


// ERC721A Contracts v4.1.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;

/**
 * @dev Interface of an ERC721A compliant contract.
 */
interface IERC721A {
    /**
     * The caller must own the token or be an approved operator.
     */
    error ApprovalCallerNotOwnerNorApproved();

    /**
     * The token does not exist.
     */
    error ApprovalQueryForNonexistentToken();

    /**
     * The caller cannot approve to their own address.
     */
    error ApproveToCaller();

    /**
     * Cannot query the balance for the zero address.
     */
    error BalanceQueryForZeroAddress();

    /**
     * Cannot mint to the zero address.
     */
    error MintToZeroAddress();

    /**
     * The quantity of tokens minted must be more than zero.
     */
    error MintZeroQuantity();

    /**
     * The token does not exist.
     */
    error OwnerQueryForNonexistentToken();

    /**
     * The caller must own the token or be an approved operator.
     */
    error TransferCallerNotOwnerNorApproved();

    /**
     * The token must be owned by `from`.
     */
    error TransferFromIncorrectOwner();

    /**
     * Cannot safely transfer to a contract that does not implement the ERC721Receiver interface.
     */
    error TransferToNonERC721ReceiverImplementer();

    /**
     * Cannot transfer to the zero address.
     */
    error TransferToZeroAddress();

    /**
     * The token does not exist.
     */
    error URIQueryForNonexistentToken();

    /**
     * The `quantity` minted with ERC2309 exceeds the safety limit.
     */
    error MintERC2309QuantityExceedsLimit();

    /**
     * The `extraData` cannot be set on an unintialized ownership slot.
     */
    error OwnershipNotInitializedForExtraData();

    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
        // Arbitrary data similar to `startTimestamp` that can be set through `_extraData`.
        uint24 extraData;
    }

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     *
     * Burned tokens are calculated here, use `_totalMinted()` if you want to count just minted tokens.
     */
    function totalSupply() external view returns (uint256);

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

    // ==============================
    //            IERC721
    // ==============================

    /**
     * @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 be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

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

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

    // ==============================
    //        IERC721Metadata
    // ==============================

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

    // ==============================
    //            IERC2309
    // ==============================

    /**
     * @dev Emitted when tokens in `fromTokenId` to `toTokenId` (inclusive) is transferred from `from` to `to`,
     * as defined in the ERC2309 standard. See `_mintERC2309` for more details.
     */
    event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);
}

// File: erc721a/contracts/ERC721A.sol


// ERC721A Contracts v4.1.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;


/**
 * @dev ERC721 token receiver interface.
 */
interface ERC721A__IERC721Receiver {
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard,
 * including the Metadata extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at `_startTokenId()`
 * (defaults to 0, e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is IERC721A {
    // Mask of an entry in packed address data.
    uint256 private constant BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;

    // The bit position of `numberMinted` in packed address data.
    uint256 private constant BITPOS_NUMBER_MINTED = 64;

    // The bit position of `numberBurned` in packed address data.
    uint256 private constant BITPOS_NUMBER_BURNED = 128;

    // The bit position of `aux` in packed address data.
    uint256 private constant BITPOS_AUX = 192;

    // Mask of all 256 bits in packed address data except the 64 bits for `aux`.
    uint256 private constant BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;

    // The bit position of `startTimestamp` in packed ownership.
    uint256 private constant BITPOS_START_TIMESTAMP = 160;

    // The bit mask of the `burned` bit in packed ownership.
    uint256 private constant BITMASK_BURNED = 1 << 224;

    // The bit position of the `nextInitialized` bit in packed ownership.
    uint256 private constant BITPOS_NEXT_INITIALIZED = 225;

    // The bit mask of the `nextInitialized` bit in packed ownership.
    uint256 private constant BITMASK_NEXT_INITIALIZED = 1 << 225;

    // The bit position of `extraData` in packed ownership.
    uint256 private constant BITPOS_EXTRA_DATA = 232;

    // Mask of all 256 bits in a packed ownership except the 24 bits for `extraData`.
    uint256 private constant BITMASK_EXTRA_DATA_COMPLEMENT = (1 << 232) - 1;

    // The mask of the lower 160 bits for addresses.
    uint256 private constant BITMASK_ADDRESS = (1 << 160) - 1;

    // The maximum `quantity` that can be minted with `_mintERC2309`.
    // This limit is to prevent overflows on the address data entries.
    // For a limit of 5000, a total of 3.689e15 calls to `_mintERC2309`
    // is required to cause an overflow, which is unrealistic.
    uint256 private constant MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000;

    // The tokenId of the next token to be minted.
    uint256 private _currentIndex;

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

    // 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 `_packedOwnershipOf` implementation for details.
    //
    // Bits Layout:
    // - [0..159]   `addr`
    // - [160..223] `startTimestamp`
    // - [224]      `burned`
    // - [225]      `nextInitialized`
    // - [232..255] `extraData`
    mapping(uint256 => uint256) private _packedOwnerships;

    // Mapping owner address to address data.
    //
    // Bits Layout:
    // - [0..63]    `balance`
    // - [64..127]  `numberMinted`
    // - [128..191] `numberBurned`
    // - [192..255] `aux`
    mapping(address => uint256) private _packedAddressData;

    // 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_;
        _currentIndex = _startTokenId();
    }

    /**
     * @dev Returns the starting token ID.
     * To change the starting token ID, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @dev Returns the next token ID to be minted.
     */
    function _nextTokenId() internal view returns (uint256) {
        return _currentIndex;
    }

    /**
     * @dev Returns the total number of tokens in existence.
     * Burned tokens will reduce the count.
     * To get the total number of tokens minted, please see `_totalMinted`.
     */
    function totalSupply() public view override returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than `_currentIndex - _startTokenId()` times.
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    /**
     * @dev Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        // Counter underflow is impossible as _currentIndex does not decrement,
        // and it is initialized to `_startTokenId()`
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

    /**
     * @dev Returns the total number of tokens burned.
     */
    function _totalBurned() internal view returns (uint256) {
        return _burnCounter;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        // The interface IDs are constants representing the first 4 bytes of the XOR of
        // all function selectors in the interface. See: https://eips.ethereum.org/EIPS/eip-165
        // e.g. `bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)`
        return
            interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165.
            interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.
            interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.
    }

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

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return (_packedAddressData[owner] >> BITPOS_NUMBER_MINTED) & BITMASK_ADDRESS_DATA_ENTRY;
    }

    /**
     * Returns the number of tokens burned by or on behalf of `owner`.
     */
    function _numberBurned(address owner) internal view returns (uint256) {
        return (_packedAddressData[owner] >> BITPOS_NUMBER_BURNED) & BITMASK_ADDRESS_DATA_ENTRY;
    }

    /**
     * Returns the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        return uint64(_packedAddressData[owner] >> BITPOS_AUX);
    }

    /**
     * Sets the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        uint256 packed = _packedAddressData[owner];
        uint256 auxCasted;
        // Cast `aux` with assembly to avoid redundant masking.
        assembly {
            auxCasted := aux
        }
        packed = (packed & BITMASK_AUX_COMPLEMENT) | (auxCasted << BITPOS_AUX);
        _packedAddressData[owner] = packed;
    }

    /**
     * Returns the packed ownership data of `tokenId`.
     */
    function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr)
                if (curr < _currentIndex) {
                    uint256 packed = _packedOwnerships[curr];
                    // If not burned.
                    if (packed & BITMASK_BURNED == 0) {
                        // Invariant:
                        // There will always be an ownership that has an address and is not burned
                        // before an ownership that does not have an address and is not burned.
                        // Hence, curr will not underflow.
                        //
                        // We can directly compare the packed value.
                        // If the address is zero, packed is zero.
                        while (packed == 0) {
                            packed = _packedOwnerships[--curr];
                        }
                        return packed;
                    }
                }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * Returns the unpacked `TokenOwnership` struct from `packed`.
     */
    function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
        ownership.addr = address(uint160(packed));
        ownership.startTimestamp = uint64(packed >> BITPOS_START_TIMESTAMP);
        ownership.burned = packed & BITMASK_BURNED != 0;
        ownership.extraData = uint24(packed >> BITPOS_EXTRA_DATA);
    }

    /**
     * Returns the unpacked `TokenOwnership` struct at `index`.
     */
    function _ownershipAt(uint256 index) internal view returns (TokenOwnership memory) {
        return _unpackedOwnership(_packedOwnerships[index]);
    }

    /**
     * @dev Initializes the ownership slot minted at `index` for efficiency purposes.
     */
    function _initializeOwnershipAt(uint256 index) internal {
        if (_packedOwnerships[index] == 0) {
            _packedOwnerships[index] = _packedOwnershipOf(index);
        }
    }

    /**
     * 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) {
        return _unpackedOwnership(_packedOwnershipOf(tokenId));
    }

    /**
     * @dev Packs ownership data into a single uint256.
     */
    function _packOwnershipData(address owner, uint256 flags) private view returns (uint256 result) {
        assembly {
            // Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
            owner := and(owner, BITMASK_ADDRESS)
            // `owner | (block.timestamp << BITPOS_START_TIMESTAMP) | flags`.
            result := or(owner, or(shl(BITPOS_START_TIMESTAMP, timestamp()), flags))
        }
    }

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

    /**
     * @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, _toString(tokenId))) : '';
    }

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

    /**
     * @dev Returns the `nextInitialized` flag set if `quantity` equals 1.
     */
    function _nextInitializedFlag(uint256 quantity) private pure returns (uint256 result) {
        // For branchless setting of the `nextInitialized` flag.
        assembly {
            // `(quantity == 1) << BITPOS_NEXT_INITIALIZED`.
            result := shl(BITPOS_NEXT_INITIALIZED, eq(quantity, 1))
        }
    }

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

        if (_msgSenderERC721A() != owner)
            if (!isApprovedForAll(owner, _msgSenderERC721A())) {
                revert ApprovalCallerNotOwnerNorApproved();
            }

        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    /**
     * @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 virtual override {
        if (operator == _msgSenderERC721A()) revert ApproveToCaller();

        _operatorApprovals[_msgSenderERC721A()][operator] = approved;
        emit ApprovalForAll(_msgSenderERC721A(), 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-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, '');
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        transferFrom(from, to, tokenId);
        if (to.code.length != 0)
            if (!_checkContractOnERC721Received(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
            _startTokenId() <= tokenId &&
            tokenId < _currentIndex && // If within bounds,
            _packedOwnerships[tokenId] & BITMASK_BURNED == 0; // and not burned.
    }

    /**
     * @dev Equivalent to `_safeMint(to, quantity, '')`.
     */
    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.
     *
     * See {_mint}.
     *
     * Emits a {Transfer} event for each mint.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        _mint(to, quantity);

        unchecked {
            if (to.code.length != 0) {
                uint256 end = _currentIndex;
                uint256 index = end - quantity;
                do {
                    if (!_checkContractOnERC721Received(address(0), to, index++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (index < end);
                // Reentrancy protection.
                if (_currentIndex != end) revert();
            }
        }
    }

    /**
     * @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 for each mint.
     */
    function _mint(address to, uint256 quantity) 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` and `numberMinted` have a maximum limit of 2**64.
        // `tokenId` has a maximum limit of 2**256.
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the `balance` and `numberMinted`.
            _packedAddressData[to] += quantity * ((1 << BITPOS_NUMBER_MINTED) | 1);

            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            _packedOwnerships[startTokenId] = _packOwnershipData(
                to,
                _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
            );

            uint256 tokenId = startTokenId;
            uint256 end = startTokenId + quantity;
            do {
                emit Transfer(address(0), to, tokenId++);
            } while (tokenId < end);

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

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * This function is intended for efficient minting only during contract creation.
     *
     * It emits only one {ConsecutiveTransfer} as defined in
     * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),
     * instead of a sequence of {Transfer} event(s).
     *
     * Calling this function outside of contract creation WILL make your contract
     * non-compliant with the ERC721 standard.
     * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309
     * {ConsecutiveTransfer} event is only permissible during contract creation.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {ConsecutiveTransfer} event.
     */
    function _mintERC2309(address to, uint256 quantity) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();
        if (quantity > MAX_MINT_ERC2309_QUANTITY_LIMIT) revert MintERC2309QuantityExceedsLimit();

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

        // Overflows are unrealistic due to the above check for `quantity` to be below the limit.
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the `balance` and `numberMinted`.
            _packedAddressData[to] += quantity * ((1 << BITPOS_NUMBER_MINTED) | 1);

            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            _packedOwnerships[startTokenId] = _packOwnershipData(
                to,
                _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
            );

            emit ConsecutiveTransfer(startTokenId, startTokenId + quantity - 1, address(0), to);

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

    /**
     * @dev Returns the storage slot and value for the approved address of `tokenId`.
     */
    function _getApprovedAddress(uint256 tokenId)
        private
        view
        returns (uint256 approvedAddressSlot, address approvedAddress)
    {
        mapping(uint256 => address) storage tokenApprovalsPtr = _tokenApprovals;
        // The following is equivalent to `approvedAddress = _tokenApprovals[tokenId]`.
        assembly {
            // Compute the slot.
            mstore(0x00, tokenId)
            mstore(0x20, tokenApprovalsPtr.slot)
            approvedAddressSlot := keccak256(0x00, 0x40)
            // Load the slot's value from storage.
            approvedAddress := sload(approvedAddressSlot)
        }
    }

    /**
     * @dev Returns whether the `approvedAddress` is equals to `from` or `msgSender`.
     */
    function _isOwnerOrApproved(
        address approvedAddress,
        address from,
        address msgSender
    ) private pure returns (bool result) {
        assembly {
            // Mask `from` to the lower 160 bits, in case the upper bits somehow aren't clean.
            from := and(from, BITMASK_ADDRESS)
            // Mask `msgSender` to the lower 160 bits, in case the upper bits somehow aren't clean.
            msgSender := and(msgSender, BITMASK_ADDRESS)
            // `msgSender == from || msgSender == approvedAddress`.
            result := or(eq(msgSender, from), eq(msgSender, approvedAddress))
        }
    }

    /**
     * @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 transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

        if (address(uint160(prevOwnershipPacked)) != from) revert TransferFromIncorrectOwner();

        (uint256 approvedAddressSlot, address approvedAddress) = _getApprovedAddress(tokenId);

        // The nested ifs save around 20+ gas over a compound boolean condition.
        if (!_isOwnerOrApproved(approvedAddress, from, _msgSenderERC721A()))
            if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();

        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner.
        assembly {
            if approvedAddress {
                // This is equivalent to `delete _tokenApprovals[tokenId]`.
                sstore(approvedAddressSlot, 0)
            }
        }

        // 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 {
            // We can directly increment and decrement the balances.
            --_packedAddressData[from]; // Updates: `balance -= 1`.
            ++_packedAddressData[to]; // Updates: `balance += 1`.

            // Updates:
            // - `address` to the next owner.
            // - `startTimestamp` to the timestamp of transfering.
            // - `burned` to `false`.
            // - `nextInitialized` to `true`.
            _packedOwnerships[tokenId] = _packOwnershipData(
                to,
                BITMASK_NEXT_INITIALIZED | _nextExtraData(from, to, prevOwnershipPacked)
            );

            // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
            if (prevOwnershipPacked & BITMASK_NEXT_INITIALIZED == 0) {
                uint256 nextTokenId = tokenId + 1;
                // If the next slot's address is zero and not burned (i.e. packed value is zero).
                if (_packedOwnerships[nextTokenId] == 0) {
                    // If the next slot is within bounds.
                    if (nextTokenId != _currentIndex) {
                        // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                        _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                    }
                }
            }
        }

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

    /**
     * @dev Equivalent to `_burn(tokenId, false)`.
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

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

        address from = address(uint160(prevOwnershipPacked));

        (uint256 approvedAddressSlot, address approvedAddress) = _getApprovedAddress(tokenId);

        if (approvalCheck) {
            // The nested ifs save around 20+ gas over a compound boolean condition.
            if (!_isOwnerOrApproved(approvedAddress, from, _msgSenderERC721A()))
                if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();
        }

        _beforeTokenTransfers(from, address(0), tokenId, 1);

        // Clear approvals from the previous owner.
        assembly {
            if approvedAddress {
                // This is equivalent to `delete _tokenApprovals[tokenId]`.
                sstore(approvedAddressSlot, 0)
            }
        }

        // 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 {
            // Updates:
            // - `balance -= 1`.
            // - `numberBurned += 1`.
            //
            // We can directly decrement the balance, and increment the number burned.
            // This is equivalent to `packed -= 1; packed += 1 << BITPOS_NUMBER_BURNED;`.
            _packedAddressData[from] += (1 << BITPOS_NUMBER_BURNED) - 1;

            // Updates:
            // - `address` to the last owner.
            // - `startTimestamp` to the timestamp of burning.
            // - `burned` to `true`.
            // - `nextInitialized` to `true`.
            _packedOwnerships[tokenId] = _packOwnershipData(
                from,
                (BITMASK_BURNED | BITMASK_NEXT_INITIALIZED) | _nextExtraData(from, address(0), prevOwnershipPacked)
            );

            // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
            if (prevOwnershipPacked & BITMASK_NEXT_INITIALIZED == 0) {
                uint256 nextTokenId = tokenId + 1;
                // If the next slot's address is zero and not burned (i.e. packed value is zero).
                if (_packedOwnerships[nextTokenId] == 0) {
                    // If the next slot is within bounds.
                    if (nextTokenId != _currentIndex) {
                        // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                        _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                    }
                }
            }
        }

        emit Transfer(from, address(0), tokenId);
        _afterTokenTransfers(from, address(0), tokenId, 1);

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

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target 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 _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        try ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns (
            bytes4 retval
        ) {
            return retval == ERC721A__IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

    /**
     * @dev Directly sets the extra data for the ownership data `index`.
     */
    function _setExtraDataAt(uint256 index, uint24 extraData) internal {
        uint256 packed = _packedOwnerships[index];
        if (packed == 0) revert OwnershipNotInitializedForExtraData();
        uint256 extraDataCasted;
        // Cast `extraData` with assembly to avoid redundant masking.
        assembly {
            extraDataCasted := extraData
        }
        packed = (packed & BITMASK_EXTRA_DATA_COMPLEMENT) | (extraDataCasted << BITPOS_EXTRA_DATA);
        _packedOwnerships[index] = packed;
    }

    /**
     * @dev Returns the next extra data for the packed ownership data.
     * The returned result is shifted into position.
     */
    function _nextExtraData(
        address from,
        address to,
        uint256 prevOwnershipPacked
    ) private view returns (uint256) {
        uint24 extraData = uint24(prevOwnershipPacked >> BITPOS_EXTRA_DATA);
        return uint256(_extraData(from, to, extraData)) << BITPOS_EXTRA_DATA;
    }

    /**
     * @dev Called during each token transfer to set the 24bit `extraData` field.
     * Intended to be overridden by the cosumer contract.
     *
     * `previousExtraData` - the value of `extraData` before transfer.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _extraData(
        address from,
        address to,
        uint24 previousExtraData
    ) internal view virtual returns (uint24) {}

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

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

    /**
     * @dev Returns the message sender (defaults to `msg.sender`).
     *
     * If you are writing GSN compatible contracts, you need to override this function.
     */
    function _msgSenderERC721A() internal view virtual returns (address) {
        return msg.sender;
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function _toString(uint256 value) internal pure returns (string memory ptr) {
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit),
            // but we allocate 128 bytes to keep the free memory pointer 32-byte word aliged.
            // We will need 1 32-byte word to store the length,
            // and 3 32-byte words to store a maximum of 78 digits. Total: 32 + 3 * 32 = 128.
            ptr := add(mload(0x40), 128)
            // Update the free memory pointer to allocate.
            mstore(0x40, ptr)

            // Cache the end of the memory to calculate the length later.
            let end := ptr

            // We write the string from the rightmost digit to the leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            // Costs a bit more than early returning for the zero case,
            // but cheaper in terms of deployment and overall runtime costs.
            for {
                // Initialize and perform the first pass without check.
                let temp := value
                // Move the pointer 1 byte leftwards to point to an empty character slot.
                ptr := sub(ptr, 1)
                // Write the character to the pointer. 48 is the ASCII index of '0'.
                mstore8(ptr, add(48, mod(temp, 10)))
                temp := div(temp, 10)
            } temp {
                // Keep dividing `temp` until zero.
                temp := div(temp, 10)
            } {
                // Body of the for loop.
                ptr := sub(ptr, 1)
                mstore8(ptr, add(48, mod(temp, 10)))
            }

            let length := sub(end, ptr)
            // Move the pointer 32 bytes leftwards to make room for the length.
            ptr := sub(ptr, 32)
            // Store the length.
            mstore(ptr, length)
        }
    }
}

// File: erc721a/contracts/extensions/IERC721AQueryable.sol


// ERC721A Contracts v4.1.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;


/**
 * @dev Interface of an ERC721AQueryable compliant contract.
 */
interface IERC721AQueryable is IERC721A {
    /**
     * Invalid query range (`start` >= `stop`).
     */
    error InvalidQueryRange();

    /**
     * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
     *
     * If the `tokenId` is out of bounds:
     *   - `addr` = `address(0)`
     *   - `startTimestamp` = `0`
     *   - `burned` = `false`
     *
     * If the `tokenId` is burned:
     *   - `addr` = `<Address of owner before token was burned>`
     *   - `startTimestamp` = `<Timestamp when token was burned>`
     *   - `burned = `true`
     *
     * Otherwise:
     *   - `addr` = `<Address of owner>`
     *   - `startTimestamp` = `<Timestamp of start of ownership>`
     *   - `burned = `false`
     */
    function explicitOwnershipOf(uint256 tokenId) external view returns (TokenOwnership memory);

    /**
     * @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
     * See {ERC721AQueryable-explicitOwnershipOf}
     */
    function explicitOwnershipsOf(uint256[] memory tokenIds) external view returns (TokenOwnership[] memory);

    /**
     * @dev Returns an array of token IDs owned by `owner`,
     * in the range [`start`, `stop`)
     * (i.e. `start <= tokenId < stop`).
     *
     * This function allows for tokens to be queried if the collection
     * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
     *
     * Requirements:
     *
     * - `start` < `stop`
     */
    function tokensOfOwnerIn(
        address owner,
        uint256 start,
        uint256 stop
    ) external view returns (uint256[] memory);

    /**
     * @dev Returns an array of token IDs owned by `owner`.
     *
     * This function scans the ownership mapping and is O(totalSupply) in complexity.
     * It is meant to be called off-chain.
     *
     * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
     * multiple smaller scans if the collection is large enough to cause
     * an out-of-gas error (10K pfp collections should be fine).
     */
    function tokensOfOwner(address owner) external view returns (uint256[] memory);
}

// File: erc721a/contracts/extensions/ERC721AQueryable.sol


// ERC721A Contracts v4.1.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;



/**
 * @title ERC721A Queryable
 * @dev ERC721A subclass with convenience query functions.
 */
abstract contract ERC721AQueryable is ERC721A, IERC721AQueryable {
    /**
     * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
     *
     * If the `tokenId` is out of bounds:
     *   - `addr` = `address(0)`
     *   - `startTimestamp` = `0`
     *   - `burned` = `false`
     *   - `extraData` = `0`
     *
     * If the `tokenId` is burned:
     *   - `addr` = `<Address of owner before token was burned>`
     *   - `startTimestamp` = `<Timestamp when token was burned>`
     *   - `burned = `true`
     *   - `extraData` = `<Extra data when token was burned>`
     *
     * Otherwise:
     *   - `addr` = `<Address of owner>`
     *   - `startTimestamp` = `<Timestamp of start of ownership>`
     *   - `burned = `false`
     *   - `extraData` = `<Extra data at start of ownership>`
     */
    function explicitOwnershipOf(uint256 tokenId) public view override returns (TokenOwnership memory) {
        TokenOwnership memory ownership;
        if (tokenId < _startTokenId() || tokenId >= _nextTokenId()) {
            return ownership;
        }
        ownership = _ownershipAt(tokenId);
        if (ownership.burned) {
            return ownership;
        }
        return _ownershipOf(tokenId);
    }

    /**
     * @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
     * See {ERC721AQueryable-explicitOwnershipOf}
     */
    function explicitOwnershipsOf(uint256[] memory tokenIds) external view override returns (TokenOwnership[] memory) {
        unchecked {
            uint256 tokenIdsLength = tokenIds.length;
            TokenOwnership[] memory ownerships = new TokenOwnership[](tokenIdsLength);
            for (uint256 i; i != tokenIdsLength; ++i) {
                ownerships[i] = explicitOwnershipOf(tokenIds[i]);
            }
            return ownerships;
        }
    }

    /**
     * @dev Returns an array of token IDs owned by `owner`,
     * in the range [`start`, `stop`)
     * (i.e. `start <= tokenId < stop`).
     *
     * This function allows for tokens to be queried if the collection
     * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
     *
     * Requirements:
     *
     * - `start` < `stop`
     */
    function tokensOfOwnerIn(
        address owner,
        uint256 start,
        uint256 stop
    ) external view override returns (uint256[] memory) {
        unchecked {
            if (start >= stop) revert InvalidQueryRange();
            uint256 tokenIdsIdx;
            uint256 stopLimit = _nextTokenId();
            // Set `start = max(start, _startTokenId())`.
            if (start < _startTokenId()) {
                start = _startTokenId();
            }
            // Set `stop = min(stop, stopLimit)`.
            if (stop > stopLimit) {
                stop = stopLimit;
            }
            uint256 tokenIdsMaxLength = balanceOf(owner);
            // Set `tokenIdsMaxLength = min(balanceOf(owner), stop - start)`,
            // to cater for cases where `balanceOf(owner)` is too big.
            if (start < stop) {
                uint256 rangeLength = stop - start;
                if (rangeLength < tokenIdsMaxLength) {
                    tokenIdsMaxLength = rangeLength;
                }
            } else {
                tokenIdsMaxLength = 0;
            }
            uint256[] memory tokenIds = new uint256[](tokenIdsMaxLength);
            if (tokenIdsMaxLength == 0) {
                return tokenIds;
            }
            // We need to call `explicitOwnershipOf(start)`,
            // because the slot at `start` may not be initialized.
            TokenOwnership memory ownership = explicitOwnershipOf(start);
            address currOwnershipAddr;
            // If the starting slot exists (i.e. not burned), initialize `currOwnershipAddr`.
            // `ownership.address` will not be zero, as `start` is clamped to the valid token ID range.
            if (!ownership.burned) {
                currOwnershipAddr = ownership.addr;
            }
            for (uint256 i = start; i != stop && tokenIdsIdx != tokenIdsMaxLength; ++i) {
                ownership = _ownershipAt(i);
                if (ownership.burned) {
                    continue;
                }
                if (ownership.addr != address(0)) {
                    currOwnershipAddr = ownership.addr;
                }
                if (currOwnershipAddr == owner) {
                    tokenIds[tokenIdsIdx++] = i;
                }
            }
            // Downsize the array to fit.
            assembly {
                mstore(tokenIds, tokenIdsIdx)
            }
            return tokenIds;
        }
    }

    /**
     * @dev Returns an array of token IDs owned by `owner`.
     *
     * This function scans the ownership mapping and is O(totalSupply) in complexity.
     * It is meant to be called off-chain.
     *
     * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
     * multiple smaller scans if the collection is large enough to cause
     * an out-of-gas error (10K pfp collections should be fine).
     */
    function tokensOfOwner(address owner) external view override returns (uint256[] memory) {
        unchecked {
            uint256 tokenIdsIdx;
            address currOwnershipAddr;
            uint256 tokenIdsLength = balanceOf(owner);
            uint256[] memory tokenIds = new uint256[](tokenIdsLength);
            TokenOwnership memory ownership;
            for (uint256 i = _startTokenId(); tokenIdsIdx != tokenIdsLength; ++i) {
                ownership = _ownershipAt(i);
                if (ownership.burned) {
                    continue;
                }
                if (ownership.addr != address(0)) {
                    currOwnershipAddr = ownership.addr;
                }
                if (currOwnershipAddr == owner) {
                    tokenIds[tokenIdsIdx++] = i;
                }
            }
            return tokenIds;
        }
    }
}

// File: contracts/3DBirds.sol





pragma solidity >=0.8.9 <0.9.0;







contract Birds3D is ERC721AQueryable, Ownable, ReentrancyGuard {
    using Strings for uint256;

    //Initial Settings ->
    string public tokenName = "3D Birds";
    string public tokenSymbol = "3DB";
    uint256 public maxSupply = 10000;
    uint256 public maxReservedSupply = 200;
    uint256 public reservedSupplyMinted = 0;
    
    uint256 public firstWaveSupply = 2700;
    
    uint256 public firstWavePrice = 0;
    uint256 public secondWavePrice = 0.03 ether;

    uint256 public wlMintAmount = 1;
    uint256 public firstWaveMaxMint = 1;
    uint256 public secondWaveMaxMint = 5;

    bytes32 public merkleRoot;
    mapping(address => uint256) public usersMinted;

    bool public paused = true;
    bool public whitelistMintEnabled = true;
    bool public revealed = false;

    string public uriPrefix = '';
    string public uriSuffix = '.json';
    string public hiddenMetadataUri = "";

    constructor(string memory _hiddenMetadataUri) ERC721A(tokenName, tokenSymbol) {
        setHiddenMetadataUri(_hiddenMetadataUri);
    }

    modifier mintCompliance(uint256 _mintAmount) {
        uint256 currentSupply = totalSupply();
        if (currentSupply < firstWaveSupply) {
            require(
                _mintAmount > 0 &&
                usersMinted[_msgSender()] + _mintAmount <= firstWaveMaxMint,
                'Too much mint in first wave'
            );
        }
        else {
            require(
                _mintAmount > 0 &&
                usersMinted[msg.sender] + _mintAmount <= secondWaveMaxMint,
                'Too much mint in second wave'
            );
            require(msg.value >= _mintAmount * secondWavePrice, 'Insufficient funds!');
        }
        _;
    }

    modifier whenWLActive() {
        require(whitelistMintEnabled == true, 'Whitelist disabled');
        _;
    }

    modifier whenPublicActive() {
        require(whitelistMintEnabled == false, 'Public disabled');
        _;
    }

    modifier noContract() {
        // i <3 @terncrypto
        require(tx.origin == msg.sender, 'Contract mint not allowed');
        // user221 write to me...
        _;
    }

    function mintPublic(uint256 _mintAmount) public payable mintCompliance(_mintAmount) whenPublicActive noContract {
        require(!paused, 'The contract is paused!');
        require(totalSupply() + _mintAmount <= (maxSupply - maxReservedSupply + reservedSupplyMinted), 'Max supply exceeded!');

        usersMinted[_msgSender()] += _mintAmount;

        _safeMint(_msgSender(), _mintAmount);
    }

    function mintWhitelist(bytes32[] calldata _merkleProof) public whenWLActive {
        bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
        require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Invalid proof!');

        require(!paused, 'The contract is paused!');
        require(usersMinted[_msgSender()] < wlMintAmount, 'You already minted WL');
        require(totalSupply() + 1 <= (maxSupply - maxReservedSupply + reservedSupplyMinted), 'Max supply exceeded!');

        usersMinted[_msgSender()] += wlMintAmount;

        _safeMint(_msgSender(), wlMintAmount);
    }

    function mintOwner(uint256 _mintAmount, address _receiver) public onlyOwner {
        require(reservedSupplyMinted + _mintAmount <= maxReservedSupply, 'Max reserved supply reached');
        require((totalSupply() + _mintAmount) <= maxSupply, 'Max supply exceeded!');
        
        reservedSupplyMinted += _mintAmount;

        _safeMint(_receiver, _mintAmount);
    }

    function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
        require(_exists(_tokenId), 'ERC721Metadata: URI query for nonexistent token');

        if (revealed == false) {
            return hiddenMetadataUri;
        }

        string memory currentBaseURI = _baseURI();
        return bytes(currentBaseURI).length > 0
        ? string(abi.encodePacked(currentBaseURI, _tokenId.toString(), uriSuffix))
        : '';
    }

    function setPaused(bool _state) public onlyOwner {
        paused = _state;
    }

    function setFirstWaveSupply(uint256 _value) public onlyOwner {
        require(_value + maxReservedSupply <= maxSupply, 'Max supply exceeded!');
        firstWaveSupply = _value;
    }

    function setFirstWaveMaxMint(uint256 _value) public onlyOwner {
        firstWaveMaxMint = _value;
    }

    function setFirstWavePrice(uint256 _value) public onlyOwner {
        firstWavePrice = _value;
    }

    function setSecondWaveMaxMint(uint256 _value) public onlyOwner {
        secondWaveMaxMint = _value;
    }

    function setSecondWavePrice(uint256 _value) public onlyOwner {
        secondWavePrice = _value;
    }

    function setRevealed(bool _state) public onlyOwner {
        revealed = _state;
    }

    function setMaxReservedSupply(uint256 _newMaxReservedSupply) public onlyOwner {
        require(_newMaxReservedSupply <= (maxSupply - totalSupply()), 'Max supply exceeded!');
        maxReservedSupply = _newMaxReservedSupply;
    }

    function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
        hiddenMetadataUri = _hiddenMetadataUri;
    }

    function setUriPrefix(string memory _uriPrefix) public onlyOwner {
        uriPrefix = _uriPrefix;
    }

    function setUriSuffix(string memory _uriSuffix) public onlyOwner {
        uriSuffix = _uriSuffix;
    }

    function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
        merkleRoot = _merkleRoot;
    }

    function setWhitelistMintEnabled(bool _state) public onlyOwner {
        whitelistMintEnabled = _state;
    }

    function withdraw() public onlyOwner nonReentrant {
        (bool os, ) = payable(owner()).call{value: address(this).balance}('');
        require(os);
    }

    // Internal ->
    function _startTokenId() internal view virtual override returns (uint256) {
        return 1;
    }

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

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"string","name":"_hiddenMetadataUri","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"InvalidQueryRange","type":"error"},{"inputs":[],"name":"MintERC2309QuantityExceedsLimit","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"OwnershipNotInitializedForExtraData","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","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":"uint256","name":"fromTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"toTokenId","type":"uint256"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"ConsecutiveTransfer","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":"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":"explicitOwnershipOf","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint64","name":"startTimestamp","type":"uint64"},{"internalType":"bool","name":"burned","type":"bool"},{"internalType":"uint24","name":"extraData","type":"uint24"}],"internalType":"struct IERC721A.TokenOwnership","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"explicitOwnershipsOf","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint64","name":"startTimestamp","type":"uint64"},{"internalType":"bool","name":"burned","type":"bool"},{"internalType":"uint24","name":"extraData","type":"uint24"}],"internalType":"struct IERC721A.TokenOwnership[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"firstWaveMaxMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"firstWavePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"firstWaveSupply","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":"hiddenMetadataUri","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"maxReservedSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"},{"internalType":"address","name":"_receiver","type":"address"}],"name":"mintOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mintPublic","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"}],"name":"mintWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reservedSupplyMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"secondWaveMaxMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"secondWavePrice","outputs":[{"internalType":"uint256","name":"","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":"uint256","name":"_value","type":"uint256"}],"name":"setFirstWaveMaxMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"setFirstWavePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"setFirstWaveSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_hiddenMetadataUri","type":"string"}],"name":"setHiddenMetadataUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newMaxReservedSupply","type":"uint256"}],"name":"setMaxReservedSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setRevealed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"setSecondWaveMaxMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"setSecondWavePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uriPrefix","type":"string"}],"name":"setUriPrefix","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uriSuffix","type":"string"}],"name":"setUriSuffix","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setWhitelistMintEnabled","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":[],"name":"tokenName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenSymbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"stop","type":"uint256"}],"name":"tokensOfOwnerIn","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uriPrefix","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uriSuffix","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"usersMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistMintEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wlMintAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

60c06040526008608081905267334420426972647360c01b60a09081526200002b91600a919062000390565b506040805180820190915260038082526219a22160e91b60209092019182526200005891600b9162000390565b50612710600c5560c8600d556000600e819055610a8c600f556010819055666a94d74f4300006011556001601281905560135560056014556017805462ffffff1916610101179055604080516020810191829052829052620000be916018919062000390565b5060408051808201909152600580825264173539b7b760d91b6020909201918252620000ed9160199162000390565b506040805160208101918290526000908190526200010e91601a9162000390565b503480156200011c57600080fd5b50604051620031dc380380620031dc8339810160408190526200013f916200044c565b600a80546200014e9062000528565b80601f01602080910402602001604051908101604052809291908181526020018280546200017c9062000528565b8015620001cd5780601f10620001a157610100808354040283529160200191620001cd565b820191906000526020600020905b815481529060010190602001808311620001af57829003601f168201915b5050505050600b8054620001e19062000528565b80601f01602080910402602001604051908101604052809291908181526020018280546200020f9062000528565b8015620002605780601f10620002345761010080835404028352916020019162000260565b820191906000526020600020905b8154815290600101906020018083116200024257829003601f168201915b505084516200027a93506002925060208601915062000390565b5080516200029090600390602084019062000390565b5050600160005550620002a333620002ba565b6001600955620002b3816200030c565b5062000565565b600880546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b620003166200032f565b80516200032b90601a90602084019062000390565b5050565b6008546001600160a01b031633146200038e5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640160405180910390fd5b565b8280546200039e9062000528565b90600052602060002090601f016020900481019282620003c257600085556200040d565b82601f10620003dd57805160ff19168380011785556200040d565b828001600101855582156200040d579182015b828111156200040d578251825591602001919060010190620003f0565b506200041b9291506200041f565b5090565b5b808211156200041b576000815560010162000420565b634e487b7160e01b600052604160045260246000fd5b600060208083850312156200046057600080fd5b82516001600160401b03808211156200047857600080fd5b818501915085601f8301126200048d57600080fd5b815181811115620004a257620004a262000436565b604051601f8201601f19908116603f01168101908382118183101715620004cd57620004cd62000436565b816040528281528886848701011115620004e657600080fd5b600093505b828410156200050a5784840186015181850187015292850192620004eb565b828411156200051c5760008684830101525b98975050505050505050565b600181811c908216806200053d57607f821691505b602082108114156200055f57634e487b7160e01b600052602260045260246000fd5b50919050565b612c6780620005756000396000f3fe6080604052600436106103765760003560e01c80637008a4a3116101d1578063a45ba8e711610102578063cb24bab2116100a0578063e8f437f21161006f578063e8f437f2146109be578063e985e9c5146109de578063efd0cbf9146109fe578063f2fde38b14610a1157600080fd5b8063cb24bab214610952578063d5abeb0114610972578063ddefaea714610988578063e0a808531461099e57600080fd5b8063c1fad42c116100dc578063c1fad42c146108cf578063c23dc68f146108e5578063c69c810d14610912578063c87b56dd1461093257600080fd5b8063a45ba8e71461087a578063b767a0981461088f578063b88d4fde146108af57600080fd5b80638462151c1161016f57806395d89b411161014957806395d89b411461080557806399a2557a1461081a5780639f15df121461083a578063a22cb4651461085a57600080fd5b80638462151c1461079a5780638da5cb5b146107c75780639201af1a146107e557600080fd5b80637b61c320116101ab5780637b61c3201461072f5780637cb64759146107445780637ec4a65914610764578063836349641461078457600080fd5b80637008a4a3146106e457806370a08231146106fa578063715018a61461071a57600080fd5b806337e8b1b3116102ab5780635503a0e81161024957806362b99ad41161022357806362b99ad41461067b5780636352211e146106905780636c02a931146106b05780636caede3d146106c557600080fd5b80635503a0e81461061f5780635bbb2177146106345780635c975abb1461066157600080fd5b806342842e0e1161028557806342842e0e1461059f57806344d84381146105bf5780634fdd43cb146105df57806351830227146105ff57600080fd5b806337e8b1b31461055e5780633ccfd60b1461057457806341a8ff2a1461058957600080fd5b8063180b4186116103185780632400a1d2116102f25780632400a1d2146104f257806324ee62ee14610512578063271b2fcc146105285780632eb4a7ab1461054857600080fd5b8063180b41861461049057806318160ddd146104bd57806323b872dd146104d257600080fd5b8063095ea7b311610354578063095ea7b31461040a5780630d7a423b1461042c57806316ba10e01461045057806316c38b3c1461047057600080fd5b806301ffc9a71461037b57806306fdde03146103b0578063081812fc146103d2575b600080fd5b34801561038757600080fd5b5061039b61039636600461247e565b610a31565b60405190151581526020015b60405180910390f35b3480156103bc57600080fd5b506103c5610a83565b6040516103a791906124f3565b3480156103de57600080fd5b506103f26103ed366004612506565b610b15565b6040516001600160a01b0390911681526020016103a7565b34801561041657600080fd5b5061042a61042536600461253b565b610b59565b005b34801561043857600080fd5b50610442600f5481565b6040519081526020016103a7565b34801561045c57600080fd5b5061042a61046b366004612602565b610bf9565b34801561047c57600080fd5b5061042a61048b36600461265a565b610c18565b34801561049c57600080fd5b506104426104ab366004612675565b60166020526000908152604090205481565b3480156104c957600080fd5b50610442610c33565b3480156104de57600080fd5b5061042a6104ed366004612690565b610c41565b3480156104fe57600080fd5b5061042a61050d366004612506565b610dd2565b34801561051e57600080fd5b5061044260115481565b34801561053457600080fd5b5061042a610543366004612506565b610ddf565b34801561055457600080fd5b5061044260155481565b34801561056a57600080fd5b50610442600e5481565b34801561058057600080fd5b5061042a610e29565b34801561059557600080fd5b5061044260135481565b3480156105ab57600080fd5b5061042a6105ba366004612690565b610f02565b3480156105cb57600080fd5b5061042a6105da3660046126cc565b610f22565b3480156105eb57600080fd5b5061042a6105fa366004612602565b611152565b34801561060b57600080fd5b5060175461039b9062010000900460ff1681565b34801561062b57600080fd5b506103c561116d565b34801561064057600080fd5b5061065461064f366004612740565b6111fb565b6040516103a79190612821565b34801561066d57600080fd5b5060175461039b9060ff1681565b34801561068757600080fd5b506103c56112c8565b34801561069c57600080fd5b506103f26106ab366004612506565b6112d5565b3480156106bc57600080fd5b506103c56112e0565b3480156106d157600080fd5b5060175461039b90610100900460ff1681565b3480156106f057600080fd5b5061044260105481565b34801561070657600080fd5b50610442610715366004612675565b6112ed565b34801561072657600080fd5b5061042a61133b565b34801561073b57600080fd5b506103c561134f565b34801561075057600080fd5b5061042a61075f366004612506565b61135c565b34801561077057600080fd5b5061042a61077f366004612602565b611369565b34801561079057600080fd5b5061044260145481565b3480156107a657600080fd5b506107ba6107b5366004612675565b611384565b6040516103a79190612863565b3480156107d357600080fd5b506008546001600160a01b03166103f2565b3480156107f157600080fd5b5061042a610800366004612506565b611493565b34801561081157600080fd5b506103c56114a0565b34801561082657600080fd5b506107ba61083536600461289b565b6114af565b34801561084657600080fd5b5061042a6108553660046128ce565b61163a565b34801561086657600080fd5b5061042a6108753660046128fa565b6116f7565b34801561088657600080fd5b506103c561178d565b34801561089b57600080fd5b5061042a6108aa36600461265a565b61179a565b3480156108bb57600080fd5b5061042a6108ca366004612924565b6117bc565b3480156108db57600080fd5b50610442600d5481565b3480156108f157600080fd5b50610905610900366004612506565b611806565b6040516103a7919061299f565b34801561091e57600080fd5b5061042a61092d366004612506565b61188e565b34801561093e57600080fd5b506103c561094d366004612506565b61189b565b34801561095e57600080fd5b5061042a61096d366004612506565b611a0a565b34801561097e57600080fd5b50610442600c5481565b34801561099457600080fd5b5061044260125481565b3480156109aa57600080fd5b5061042a6109b936600461265a565b611a45565b3480156109ca57600080fd5b5061042a6109d9366004612506565b611a69565b3480156109ea57600080fd5b5061039b6109f93660046129ad565b611a76565b61042a610a0c366004612506565b611aa4565b348015610a1d57600080fd5b5061042a610a2c366004612675565b611d65565b60006301ffc9a760e01b6001600160e01b031983161480610a6257506380ac58cd60e01b6001600160e01b03198316145b80610a7d5750635b5e139f60e01b6001600160e01b03198316145b92915050565b606060028054610a92906129d7565b80601f0160208091040260200160405190810160405280929190818152602001828054610abe906129d7565b8015610b0b5780601f10610ae057610100808354040283529160200191610b0b565b820191906000526020600020905b815481529060010190602001808311610aee57829003601f168201915b5050505050905090565b6000610b2082611dde565b610b3d576040516333d1c03960e21b815260040160405180910390fd5b506000908152600660205260409020546001600160a01b031690565b6000610b64826112d5565b9050336001600160a01b03821614610b9d57610b808133611a76565b610b9d576040516367d9dca160e11b815260040160405180910390fd5b60008281526006602052604080822080546001600160a01b0319166001600160a01b0387811691821790925591518593918516917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591a4505050565b610c01611e13565b8051610c149060199060208401906123cf565b5050565b610c20611e13565b6017805460ff1916911515919091179055565b600154600054036000190190565b6000610c4c82611e6d565b9050836001600160a01b0316816001600160a01b031614610c7f5760405162a1148160e81b815260040160405180910390fd5b60008281526006602052604090208054338082146001600160a01b03881690911417610ccc57610caf8633611a76565b610ccc57604051632ce44b5f60e11b815260040160405180910390fd5b6001600160a01b038516610cf357604051633a954ecd60e21b815260040160405180910390fd5b8015610cfe57600082555b6001600160a01b038681166000908152600560205260408082208054600019019055918716808252919020805460010190554260a01b17600160e11b17600085815260046020526040902055600160e11b8316610d895760018401600081815260046020526040902054610d87576000548114610d875760008181526004602052604090208490555b505b83856001600160a01b0316876001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a4505050505050565b610dda611e13565b601155565b610de7611e13565b610def610c33565b600c54610dfc9190612a28565b811115610e245760405162461bcd60e51b8152600401610e1b90612a3f565b60405180910390fd5b600d55565b610e31611e13565b60026009541415610e845760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c006044820152606401610e1b565b60026009556000610e9d6008546001600160a01b031690565b6001600160a01b03164760405160006040518083038185875af1925050503d8060008114610ee7576040519150601f19603f3d011682016040523d82523d6000602084013e610eec565b606091505b5050905080610efa57600080fd5b506001600955565b610f1d838383604051806020016040528060008152506117bc565b505050565b60175460ff610100909104161515600114610f745760405162461bcd60e51b815260206004820152601260248201527115da1a5d195b1a5cdd08191a5cd8589b195960721b6044820152606401610e1b565b6040516bffffffffffffffffffffffff193360601b166020820152600090603401604051602081830303815290604052805190602001209050610fee838380806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250506015549150849050611ed6565b61102b5760405162461bcd60e51b815260206004820152600e60248201526d496e76616c69642070726f6f662160901b6044820152606401610e1b565b60175460ff16156110785760405162461bcd60e51b815260206004820152601760248201527654686520636f6e7472616374206973207061757365642160481b6044820152606401610e1b565b60125433600090815260166020526040902054106110d05760405162461bcd60e51b8152602060048201526015602482015274165bdd48185b1c9958591e481b5a5b9d19590815d3605a1b6044820152606401610e1b565b600e54600d54600c546110e39190612a28565b6110ed9190612a6d565b6110f5610c33565b611100906001612a6d565b111561111e5760405162461bcd60e51b8152600401610e1b90612a3f565b6012543360009081526016602052604081208054909190611140908490612a6d565b90915550610f1d905033601254611eec565b61115a611e13565b8051610c1490601a9060208401906123cf565b6019805461117a906129d7565b80601f01602080910402602001604051908101604052809291908181526020018280546111a6906129d7565b80156111f35780601f106111c8576101008083540402835291602001916111f3565b820191906000526020600020905b8154815290600101906020018083116111d657829003601f168201915b505050505081565b80516060906000816001600160401b0381111561121a5761121a612565565b60405190808252806020026020018201604052801561126c57816020015b6040805160808101825260008082526020808301829052928201819052606082015282526000199092019101816112385790505b50905060005b8281146112c05761129b85828151811061128e5761128e612a85565b6020026020010151611806565b8282815181106112ad576112ad612a85565b6020908102919091010152600101611272565b509392505050565b6018805461117a906129d7565b6000610a7d82611e6d565b600a805461117a906129d7565b60006001600160a01b038216611316576040516323d3ad8160e21b815260040160405180910390fd5b506001600160a01b03166000908152600560205260409020546001600160401b031690565b611343611e13565b61134d6000611f06565b565b600b805461117a906129d7565b611364611e13565b601555565b611371611e13565b8051610c149060189060208401906123cf565b60606000806000611394856112ed565b90506000816001600160401b038111156113b0576113b0612565565b6040519080825280602002602001820160405280156113d9578160200160208202803683370190505b50905061140660408051608081018252600080825260208201819052918101829052606081019190915290565b60015b8386146114875761141981611f58565b915081604001511561142a5761147f565b81516001600160a01b03161561143f57815194505b876001600160a01b0316856001600160a01b0316141561147f578083878060010198508151811061147257611472612a85565b6020026020010181815250505b600101611409565b50909695505050505050565b61149b611e13565b601055565b606060038054610a92906129d7565b60608183106114d157604051631960ccad60e11b815260040160405180910390fd5b6000806114dd60005490565b905060018510156114ed57600194505b808411156114f9578093505b6000611504876112ed565b905084861015611523578585038181101561151d578091505b50611527565b5060005b6000816001600160401b0381111561154157611541612565565b60405190808252806020026020018201604052801561156a578160200160208202803683370190505b5090508161157d57935061163392505050565b600061158888611806565b905060008160400151611599575080515b885b8881141580156115ab5750848714155b15611627576115b981611f58565b92508260400151156115ca5761161f565b82516001600160a01b0316156115df57825191505b8a6001600160a01b0316826001600160a01b0316141561161f578084888060010199508151811061161257611612612a85565b6020026020010181815250505b60010161159b565b50505092835250909150505b9392505050565b611642611e13565b600d5482600e546116539190612a6d565b11156116a15760405162461bcd60e51b815260206004820152601b60248201527f4d617820726573657276656420737570706c79207265616368656400000000006044820152606401610e1b565b600c54826116ad610c33565b6116b79190612a6d565b11156116d55760405162461bcd60e51b8152600401610e1b90612a3f565b81600e60008282546116e79190612a6d565b90915550610c1490508183611eec565b6001600160a01b0382163314156117215760405163b06307db60e01b815260040160405180910390fd5b3360008181526007602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b601a805461117a906129d7565b6117a2611e13565b601780549115156101000261ff0019909216919091179055565b6117c7848484610c41565b6001600160a01b0383163b15611800576117e384848484611f94565b611800576040516368d2bf6b60e11b815260040160405180910390fd5b50505050565b604080516080810182526000808252602082018190529181018290526060810191909152604080516080810182526000808252602082018190529181018290526060810191909152600183108061185f57506000548310155b1561186a5792915050565b61187383611f58565b90508060400151156118855792915050565b6116338361208c565b611896611e13565b601455565b60606118a682611dde565b61190a5760405162461bcd60e51b815260206004820152602f60248201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60448201526e3732bc34b9ba32b73a103a37b5b2b760891b6064820152608401610e1b565b60175462010000900460ff166119ac57601a8054611927906129d7565b80601f0160208091040260200160405190810160405280929190818152602001828054611953906129d7565b80156119a05780601f10611975576101008083540402835291602001916119a0565b820191906000526020600020905b81548152906001019060200180831161198357829003601f168201915b50505050509050919050565b60006119b66120c1565b905060008151116119d65760405180602001604052806000815250611633565b806119e0846120d0565b60196040516020016119f493929190612a9b565b6040516020818303038152906040529392505050565b611a12611e13565b600c54600d54611a229083612a6d565b1115611a405760405162461bcd60e51b8152600401610e1b90612a3f565b600f55565b611a4d611e13565b60178054911515620100000262ff000019909216919091179055565b611a71611e13565b601355565b6001600160a01b03918216600090815260076020908152604080832093909416825291909152205460ff1690565b806000611aaf610c33565b9050600f54811015611b3857600082118015611ae7575060135433600090815260166020526040902054611ae4908490612a6d565b11155b611b335760405162461bcd60e51b815260206004820152601b60248201527f546f6f206d756368206d696e7420696e206669727374207761766500000000006044820152606401610e1b565b611c02565b600082118015611b64575060145433600090815260166020526040902054611b61908490612a6d565b11155b611bb05760405162461bcd60e51b815260206004820152601c60248201527f546f6f206d756368206d696e7420696e207365636f6e642077617665000000006044820152606401610e1b565b601154611bbd9083612b5f565b341015611c025760405162461bcd60e51b8152602060048201526013602482015272496e73756666696369656e742066756e64732160681b6044820152606401610e1b565b601754610100900460ff1615611c4c5760405162461bcd60e51b815260206004820152600f60248201526e141d589b1a58c8191a5cd8589b1959608a1b6044820152606401610e1b565b323314611c9b5760405162461bcd60e51b815260206004820152601960248201527f436f6e7472616374206d696e74206e6f7420616c6c6f776564000000000000006044820152606401610e1b565b60175460ff1615611ce85760405162461bcd60e51b815260206004820152601760248201527654686520636f6e7472616374206973207061757365642160481b6044820152606401610e1b565b600e54600d54600c54611cfb9190612a28565b611d059190612a6d565b83611d0e610c33565b611d189190612a6d565b1115611d365760405162461bcd60e51b8152600401610e1b90612a3f565b3360009081526016602052604081208054859290611d55908490612a6d565b90915550610f1d90503384611eec565b611d6d611e13565b6001600160a01b038116611dd25760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610e1b565b611ddb81611f06565b50565b600081600111158015611df2575060005482105b8015610a7d575050600090815260046020526040902054600160e01b161590565b6008546001600160a01b0316331461134d5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610e1b565b60008180600111611ebd57600054811015611ebd57600081815260046020526040902054600160e01b8116611ebb575b80611633575060001901600081815260046020526040902054611e9d565b505b604051636f96cda160e11b815260040160405180910390fd5b600082611ee385846121cd565b14949350505050565b610c14828260405180602001604052806000815250612212565b600880546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b604080516080810182526000808252602082018190529181018290526060810191909152600082815260046020526040902054610a7d9061227f565b604051630a85bd0160e11b81526000906001600160a01b0385169063150b7a0290611fc9903390899088908890600401612b7e565b602060405180830381600087803b158015611fe357600080fd5b505af1925050508015612013575060408051601f3d908101601f1916820190925261201091810190612bbb565b60015b61206e573d808015612041576040519150601f19603f3d011682016040523d82523d6000602084013e612046565b606091505b508051612066576040516368d2bf6b60e11b815260040160405180910390fd5b805181602001fd5b6001600160e01b031916630a85bd0160e11b1490505b949350505050565b604080516080810182526000808252602082018190529181018290526060810191909152610a7d6120bc83611e6d565b61227f565b606060188054610a92906129d7565b6060816120f45750506040805180820190915260018152600360fc1b602082015290565b8160005b811561211e578061210881612bd8565b91506121179050600a83612c09565b91506120f8565b6000816001600160401b0381111561213857612138612565565b6040519080825280601f01601f191660200182016040528015612162576020820181803683370190505b5090505b841561208457612177600183612a28565b9150612184600a86612c1d565b61218f906030612a6d565b60f81b8183815181106121a4576121a4612a85565b60200101906001600160f81b031916908160001a9053506121c6600a86612c09565b9450612166565b600081815b84518110156112c0576121fe828683815181106121f1576121f1612a85565b60200260200101516122c6565b91508061220a81612bd8565b9150506121d2565b61221c83836122f2565b6001600160a01b0383163b15610f1d576000548281035b6122466000868380600101945086611f94565b612263576040516368d2bf6b60e11b815260040160405180910390fd5b81811061223357816000541461227857600080fd5b5050505050565b604080516080810182526001600160a01b038316815260a083901c6001600160401b03166020820152600160e01b831615159181019190915260e89190911c606082015290565b60008183106122e2576000828152602084905260409020611633565b5060009182526020526040902090565b6000546001600160a01b03831661231b57604051622e076360e81b815260040160405180910390fd5b816123395760405163b562e8dd60e01b815260040160405180910390fd5b6001600160a01b038316600081815260056020526040902080546801000000000000000185020190554260a01b6001841460e11b1717600082815260046020526040902055808281015b6040516001830192906001600160a01b038716906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a48082106123835760005550505050565b8280546123db906129d7565b90600052602060002090601f0160209004810192826123fd5760008555612443565b82601f1061241657805160ff1916838001178555612443565b82800160010185558215612443579182015b82811115612443578251825591602001919060010190612428565b5061244f929150612453565b5090565b5b8082111561244f5760008155600101612454565b6001600160e01b031981168114611ddb57600080fd5b60006020828403121561249057600080fd5b813561163381612468565b60005b838110156124b657818101518382015260200161249e565b838111156118005750506000910152565b600081518084526124df81602086016020860161249b565b601f01601f19169290920160200192915050565b60208152600061163360208301846124c7565b60006020828403121561251857600080fd5b5035919050565b80356001600160a01b038116811461253657600080fd5b919050565b6000806040838503121561254e57600080fd5b6125578361251f565b946020939093013593505050565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f191681016001600160401b03811182821017156125a3576125a3612565565b604052919050565b60006001600160401b038311156125c4576125c4612565565b6125d7601f8401601f191660200161257b565b90508281528383830111156125eb57600080fd5b828260208301376000602084830101529392505050565b60006020828403121561261457600080fd5b81356001600160401b0381111561262a57600080fd5b8201601f8101841361263b57600080fd5b612084848235602084016125ab565b8035801515811461253657600080fd5b60006020828403121561266c57600080fd5b6116338261264a565b60006020828403121561268757600080fd5b6116338261251f565b6000806000606084860312156126a557600080fd5b6126ae8461251f565b92506126bc6020850161251f565b9150604084013590509250925092565b600080602083850312156126df57600080fd5b82356001600160401b03808211156126f657600080fd5b818501915085601f83011261270a57600080fd5b81358181111561271957600080fd5b8660208260051b850101111561272e57600080fd5b60209290920196919550909350505050565b6000602080838503121561275357600080fd5b82356001600160401b038082111561276a57600080fd5b818501915085601f83011261277e57600080fd5b81358181111561279057612790612565565b8060051b91506127a184830161257b565b81815291830184019184810190888411156127bb57600080fd5b938501935b838510156127d9578435825293850193908501906127c0565b98975050505050505050565b80516001600160a01b031682526020808201516001600160401b03169083015260408082015115159083015260609081015162ffffff16910152565b6020808252825182820181905260009190848201906040850190845b81811015611487576128508385516127e5565b928401926080929092019160010161283d565b6020808252825182820181905260009190848201906040850190845b818110156114875783518352928401929184019160010161287f565b6000806000606084860312156128b057600080fd5b6128b98461251f565b95602085013595506040909401359392505050565b600080604083850312156128e157600080fd5b823591506128f16020840161251f565b90509250929050565b6000806040838503121561290d57600080fd5b6129168361251f565b91506128f16020840161264a565b6000806000806080858703121561293a57600080fd5b6129438561251f565b93506129516020860161251f565b92506040850135915060608501356001600160401b0381111561297357600080fd5b8501601f8101871361298457600080fd5b612993878235602084016125ab565b91505092959194509250565b60808101610a7d82846127e5565b600080604083850312156129c057600080fd5b6129c98361251f565b91506128f16020840161251f565b600181811c908216806129eb57607f821691505b60208210811415612a0c57634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fd5b600082821015612a3a57612a3a612a12565b500390565b6020808252601490820152734d617820737570706c792065786365656465642160601b604082015260600190565b60008219821115612a8057612a80612a12565b500190565b634e487b7160e01b600052603260045260246000fd5b600084516020612aae8285838a0161249b565b855191840191612ac18184848a0161249b565b8554920191600090600181811c9080831680612ade57607f831692505b858310811415612afc57634e487b7160e01b85526022600452602485fd5b808015612b105760018114612b2157612b4e565b60ff19851688528388019550612b4e565b60008b81526020902060005b85811015612b465781548a820152908401908801612b2d565b505083880195505b50939b9a5050505050505050505050565b6000816000190483118215151615612b7957612b79612a12565b500290565b6001600160a01b0385811682528416602082015260408101839052608060608201819052600090612bb1908301846124c7565b9695505050505050565b600060208284031215612bcd57600080fd5b815161163381612468565b6000600019821415612bec57612bec612a12565b5060010190565b634e487b7160e01b600052601260045260246000fd5b600082612c1857612c18612bf3565b500490565b600082612c2c57612c2c612bf3565b50069056fea2646970667358221220e8df2bb1cdefc043df9fb8a6c1d7e024e5204f9e023f3f04c670f5057adff0b864736f6c6343000809003300000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000036697066733a2f2f516d59396a48775664715733564e6e555858377876576e4a696371777178775361686d507a4b53314b6f4b3677672f00000000000000000000

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

00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000036697066733a2f2f516d59396a48775664715733564e6e555858377876576e4a696371777178775361686d507a4b53314b6f4b3677672f00000000000000000000

-----Decoded View---------------
Arg [0] : _hiddenMetadataUri (string): ipfs://QmY9jHwVdqW3VNnUXX7xvWnJicqwqxwSahmPzKS1KoK6wg/

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000036
Arg [2] : 697066733a2f2f516d59396a48775664715733564e6e555858377876576e4a69
Arg [3] : 6371777178775361686d507a4b53314b6f4b3677672f00000000000000000000


Deployed ByteCode Sourcemap

72203:6191:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33177:615;;;;;;;;;;-1:-1:-1;33177:615:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;33177:615:0;;;;;;;;38824:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;40770:204::-;;;;;;;;;;-1:-1:-1;40770:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1692:32:1;;;1674:51;;1662:2;1647:18;40770:204:0;1528:203:1;40318:386:0;;;;;;;;;;-1:-1:-1;40318:386:0;;;;;:::i;:::-;;:::i;:::-;;72553:37;;;;;;;;;;;;;;;;;;;2319:25:1;;;2307:2;2292:18;72553:37:0;2173:177:1;77639:106:0;;;;;;;;;;-1:-1:-1;77639:106:0;;;;;:::i;:::-;;:::i;76304:83::-;;;;;;;;;;-1:-1:-1;76304:83:0;;;;;:::i;:::-;;:::i;72852:46::-;;;;;;;;;;-1:-1:-1;72852:46:0;;;;;:::i;:::-;;;;;;;;;;;;;;32231:315;;;;;;;;;;;;;:::i;50035:2800::-;;;;;;;;;;-1:-1:-1;50035:2800:0;;;;;:::i;:::-;;:::i;76930:104::-;;;;;;;;;;-1:-1:-1;76930:104:0;;;;;:::i;:::-;;:::i;72643:43::-;;;;;;;;;;;;;;;;77137:234;;;;;;;;;;-1:-1:-1;77137:234:0;;;;;:::i;:::-;;:::i;72820:25::-;;;;;;;;;;;;;;;;72501:39;;;;;;;;;;;;;;;;77984:160;;;;;;;;;;;;;:::i;72733:35::-;;;;;;;;;;;;;;;;41660:185;;;;;;;;;;-1:-1:-1;41660:185:0;;;;;:::i;:::-;;:::i;74826:603::-;;;;;;;;;;-1:-1:-1;74826:603:0;;;;;:::i;:::-;;:::i;77379:138::-;;;;;;;;;;-1:-1:-1;77379:138:0;;;;;:::i;:::-;;:::i;72985:28::-;;;;;;;;;;-1:-1:-1;72985:28:0;;;;;;;;;;;73057:33;;;;;;;;;;;;;:::i;67403:468::-;;;;;;;;;;-1:-1:-1;67403:468:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;72907:25::-;;;;;;;;;;-1:-1:-1;72907:25:0;;;;;;;;73022:28;;;;;;;;;;;;;:::i;38613:144::-;;;;;;;;;;-1:-1:-1;38613:144:0;;;;;:::i;:::-;;:::i;72334:36::-;;;;;;;;;;;;;:::i;72939:39::-;;;;;;;;;;-1:-1:-1;72939:39:0;;;;;;;;;;;72603:33;;;;;;;;;;;;;;;;33856:224;;;;;;;;;;-1:-1:-1;33856:224:0;;;;;:::i;:::-;;:::i;17768:103::-;;;;;;;;;;;;;:::i;72377:33::-;;;;;;;;;;;;;:::i;77753:104::-;;;;;;;;;;-1:-1:-1;77753:104:0;;;;;:::i;:::-;;:::i;77525:106::-;;;;;;;;;;-1:-1:-1;77525:106:0;;;;;:::i;:::-;;:::i;72775:36::-;;;;;;;;;;;;;;;;71215:892;;;;;;;;;;-1:-1:-1;71215:892:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;17120:87::-;;;;;;;;;;-1:-1:-1;17193:6:0;;-1:-1:-1;;;;;17193:6:0;17120:87;;76704:102;;;;;;;;;;-1:-1:-1;76704:102:0;;;;;:::i;:::-;;:::i;38993:104::-;;;;;;;;;;;;;:::i;68261:2505::-;;;;;;;;;;-1:-1:-1;68261:2505:0;;;;;:::i;:::-;;:::i;75437:378::-;;;;;;;;;;-1:-1:-1;75437:378:0;;;;;:::i;:::-;;:::i;41046:308::-;;;;;;;;;;-1:-1:-1;41046:308:0;;;;;:::i;:::-;;:::i;73097:36::-;;;;;;;;;;;;;:::i;77865:111::-;;;;;;;;;;-1:-1:-1;77865:111:0;;;;;:::i;:::-;;:::i;41916:399::-;;;;;;;;;;-1:-1:-1;41916:399:0;;;;;:::i;:::-;;:::i;72456:38::-;;;;;;;;;;;;;;;;66824:420;;;;;;;;;;-1:-1:-1;66824:420:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;76814:108::-;;;;;;;;;;-1:-1:-1;76814:108:0;;;;;:::i;:::-;;:::i;75823:473::-;;;;;;;;;;-1:-1:-1;75823:473:0;;;;;:::i;:::-;;:::i;76395:187::-;;;;;;;;;;-1:-1:-1;76395:187:0;;;;;:::i;:::-;;:::i;72417:32::-;;;;;;;;;;;;;;;;72695:31;;;;;;;;;;;;;;;;77042:87;;;;;;;;;;-1:-1:-1;77042:87:0;;;;;:::i;:::-;;:::i;76590:106::-;;;;;;;;;;-1:-1:-1;76590:106:0;;;;;:::i;:::-;;:::i;41425:164::-;;;;;;;;;;-1:-1:-1;41425:164:0;;;;;:::i;:::-;;:::i;74413:405::-;;;;;;:::i;:::-;;:::i;18026:201::-;;;;;;;;;;-1:-1:-1;18026:201:0;;;;;:::i;:::-;;:::i;33177:615::-;33262:4;-1:-1:-1;;;;;;;;;33562:25:0;;;;:102;;-1:-1:-1;;;;;;;;;;33639:25:0;;;33562:102;:179;;;-1:-1:-1;;;;;;;;;;33716:25:0;;;33562:179;33542:199;33177:615;-1:-1:-1;;33177:615:0:o;38824:100::-;38878:13;38911:5;38904:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38824:100;:::o;40770:204::-;40838:7;40863:16;40871:7;40863;:16::i;:::-;40858:64;;40888:34;;-1:-1:-1;;;40888:34:0;;;;;;;;;;;40858:64;-1:-1:-1;40942:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;40942:24:0;;40770:204::o;40318:386::-;40391:13;40407:16;40415:7;40407;:16::i;:::-;40391:32;-1:-1:-1;61218:10:0;-1:-1:-1;;;;;40440:28:0;;;40436:175;;40488:44;40505:5;61218:10;41425:164;:::i;40488:44::-;40483:128;;40560:35;;-1:-1:-1;;;40560:35:0;;;;;;;;;;;40483:128;40623:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;40623:29:0;-1:-1:-1;;;;;40623:29:0;;;;;;;;;40668:28;;40623:24;;40668:28;;;;;;;40380:324;40318:386;;:::o;77639:106::-;17006:13;:11;:13::i;:::-;77715:22;;::::1;::::0;:9:::1;::::0;:22:::1;::::0;::::1;::::0;::::1;:::i;:::-;;77639:106:::0;:::o;76304:83::-;17006:13;:11;:13::i;:::-;76364:6:::1;:15:::0;;-1:-1:-1;;76364:15:0::1;::::0;::::1;;::::0;;;::::1;::::0;;76304:83::o;32231:315::-;78264:1;32497:12;32284:7;32481:13;:28;-1:-1:-1;;32481:46:0;;32231:315::o;50035:2800::-;50169:27;50199;50218:7;50199:18;:27::i;:::-;50169:57;;50284:4;-1:-1:-1;;;;;50243:45:0;50259:19;-1:-1:-1;;;;;50243:45:0;;50239:86;;50297:28;;-1:-1:-1;;;50297:28:0;;;;;;;;;;;50239:86;50339:27;48765:21;;;48592:15;48807:4;48800:36;48889:4;48873:21;;48979:26;;61218:10;49732:30;;;-1:-1:-1;;;;;49430:26:0;;49711:19;;;49708:55;50518:174;;50605:43;50622:4;61218:10;41425:164;:::i;50605:43::-;50600:92;;50657:35;;-1:-1:-1;;;50657:35:0;;;;;;;;;;;50600:92;-1:-1:-1;;;;;50709:16:0;;50705:52;;50734:23;;-1:-1:-1;;;50734:23:0;;;;;;;;;;;50705:52;50906:15;50903:160;;;51046:1;51025:19;51018:30;50903:160;-1:-1:-1;;;;;51441:24:0;;;;;;;:18;:24;;;;;;51439:26;;-1:-1:-1;;51439:26:0;;;51510:22;;;;;;;;;51508:24;;-1:-1:-1;51508:24:0;;;38512:11;38488:22;38484:40;38471:62;-1:-1:-1;;;38471:62:0;51803:26;;;;:17;:26;;;;;:174;-1:-1:-1;;;52097:46:0;;52093:626;;52201:1;52191:11;;52169:19;52324:30;;;:17;:30;;;;;;52320:384;;52462:13;;52447:11;:28;52443:242;;52609:30;;;;:17;:30;;;;;:52;;;52443:242;52150:569;52093:626;52766:7;52762:2;-1:-1:-1;;;;;52747:27:0;52756:4;-1:-1:-1;;;;;52747:27:0;;;;;;;;;;;50158:2677;;;50035:2800;;;:::o;76930:104::-;17006:13;:11;:13::i;:::-;77002:15:::1;:24:::0;76930:104::o;77137:234::-;17006:13;:11;:13::i;:::-;77272::::1;:11;:13::i;:::-;77260:9;;:25;;;;:::i;:::-;77234:21;:52;;77226:85;;;;-1:-1:-1::0;;;77226:85:0::1;;;;;;;:::i;:::-;;;;;;;;;77322:17;:41:::0;77137:234::o;77984:160::-;17006:13;:11;:13::i;:::-;2823:1:::1;3421:7;;:19;;3413:63;;;::::0;-1:-1:-1;;;3413:63:0;;11416:2:1;3413:63:0::1;::::0;::::1;11398:21:1::0;11455:2;11435:18;;;11428:30;11494:33;11474:18;;;11467:61;11545:18;;3413:63:0::1;11214:355:1::0;3413:63:0::1;2823:1;3554:7;:18:::0;78046:7:::2;78067;17193:6:::0;;-1:-1:-1;;;;;17193:6:0;;17120:87;78067:7:::2;-1:-1:-1::0;;;;;78059:21:0::2;78088;78059:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78045:69;;;78133:2;78125:11;;;::::0;::::2;;-1:-1:-1::0;2779:1:0::1;3733:7;:22:::0;77984:160::o;41660:185::-;41798:39;41815:4;41821:2;41825:7;41798:39;;;;;;;;;;;;:16;:39::i;:::-;41660:185;;;:::o;74826:603::-;74024:20;;;;;;;;:28;;:20;:28;74016:59;;;;-1:-1:-1;;;74016:59:0;;11986:2:1;74016:59:0;;;11968:21:1;12025:2;12005:18;;;11998:30;-1:-1:-1;;;12044:18:1;;;12037:48;12102:18;;74016:59:0;11784:342:1;74016:59:0;74938:30:::1;::::0;-1:-1:-1;;61218:10:0;12280:2:1;12276:15;12272:53;74938:30:0::1;::::0;::::1;12260:66:1::0;74913:12:0::1;::::0;12342::1;;74938:30:0::1;;;;;;;;;;;;74928:41;;;;;;74913:56;;74988:50;75007:12;;74988:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;75021:10:0::1;::::0;;-1:-1:-1;75033:4:0;;-1:-1:-1;74988:18:0::1;:50::i;:::-;74980:77;;;::::0;-1:-1:-1;;;74980:77:0;;12567:2:1;74980:77:0::1;::::0;::::1;12549:21:1::0;12606:2;12586:18;;;12579:30;-1:-1:-1;;;12625:18:1;;;12618:44;12679:18;;74980:77:0::1;12365:338:1::0;74980:77:0::1;75079:6;::::0;::::1;;75078:7;75070:43;;;::::0;-1:-1:-1;;;75070:43:0;;12910:2:1;75070:43:0::1;::::0;::::1;12892:21:1::0;12949:2;12929:18;;;12922:30;-1:-1:-1;;;12968:18:1;;;12961:53;13031:18;;75070:43:0::1;12708:347:1::0;75070:43:0::1;75160:12;::::0;61218:10;75132:25:::1;::::0;;;:11:::1;:25;::::0;;;;;:40:::1;75124:74;;;::::0;-1:-1:-1;;;75124:74:0;;13262:2:1;75124:74:0::1;::::0;::::1;13244:21:1::0;13301:2;13281:18;;;13274:30;-1:-1:-1;;;13320:18:1;;;13313:51;13381:18;;75124:74:0::1;13060:345:1::0;75124:74:0::1;75271:20;;75251:17;;75239:9;;:29;;;;:::i;:::-;:52;;;;:::i;:::-;75217:13;:11;:13::i;:::-;:17;::::0;75233:1:::1;75217:17;:::i;:::-;:75;;75209:108;;;;-1:-1:-1::0;;;75209:108:0::1;;;;;;;:::i;:::-;75359:12;::::0;61218:10;75330:25:::1;::::0;;;:11:::1;:25;::::0;;;;:41;;:25;;;:41:::1;::::0;75359:12;;75330:41:::1;:::i;:::-;::::0;;;-1:-1:-1;75384:37:0::1;::::0;-1:-1:-1;61218:10:0;75408:12:::1;;75384:9;:37::i;77379:138::-:0;17006:13;:11;:13::i;:::-;77471:38;;::::1;::::0;:17:::1;::::0;:38:::1;::::0;::::1;::::0;::::1;:::i;73057:33::-:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;67403:468::-;67578:15;;67492:23;;67553:22;67578:15;-1:-1:-1;;;;;67645:36:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67645:36:0;;-1:-1:-1;;67645:36:0;;;;;;;;;;;;67608:73;;67701:9;67696:125;67717:14;67712:1;:19;67696:125;;67773:32;67793:8;67802:1;67793:11;;;;;;;;:::i;:::-;;;;;;;67773:19;:32::i;:::-;67757:10;67768:1;67757:13;;;;;;;;:::i;:::-;;;;;;;;;;:48;67733:3;;67696:125;;;-1:-1:-1;67842:10:0;67403:468;-1:-1:-1;;;67403:468:0:o;73022:28::-;;;;;;;:::i;38613:144::-;38677:7;38720:27;38739:7;38720:18;:27::i;72334:36::-;;;;;;;:::i;33856:224::-;33920:7;-1:-1:-1;;;;;33944:19:0;;33940:60;;33972:28;;-1:-1:-1;;;33972:28:0;;;;;;;;;;;33940:60;-1:-1:-1;;;;;;34018:25:0;;;;;:18;:25;;;;;;-1:-1:-1;;;;;34018:54:0;;33856:224::o;17768:103::-;17006:13;:11;:13::i;:::-;17833:30:::1;17860:1;17833:18;:30::i;:::-;17768:103::o:0;72377:33::-;;;;;;;:::i;77753:104::-;17006:13;:11;:13::i;:::-;77825:10:::1;:24:::0;77753:104::o;77525:106::-;17006:13;:11;:13::i;:::-;77601:22;;::::1;::::0;:9:::1;::::0;:22:::1;::::0;::::1;::::0;::::1;:::i;71215:892::-:0;71285:16;71339:19;71373:25;71413:22;71438:16;71448:5;71438:9;:16::i;:::-;71413:41;;71469:25;71511:14;-1:-1:-1;;;;;71497:29:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71497:29:0;;71469:57;;71541:31;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71541:31:0;78264:1;71587:472;71636:14;71621:11;:29;71587:472;;71688:15;71701:1;71688:12;:15::i;:::-;71676:27;;71726:9;:16;;;71722:73;;;71767:8;;71722:73;71817:14;;-1:-1:-1;;;;;71817:28:0;;71813:111;;71890:14;;;-1:-1:-1;71813:111:0;71967:5;-1:-1:-1;;;;;71946:26:0;:17;-1:-1:-1;;;;;71946:26:0;;71942:102;;;72023:1;71997:8;72006:13;;;;;;71997:23;;;;;;;;:::i;:::-;;;;;;:27;;;;;71942:102;71652:3;;71587:472;;;-1:-1:-1;72080:8:0;;71215:892;-1:-1:-1;;;;;;71215:892:0:o;76704:102::-;17006:13;:11;:13::i;:::-;76775:14:::1;:23:::0;76704:102::o;38993:104::-;39049:13;39082:7;39075:14;;;;;:::i;68261:2505::-;68396:16;68463:4;68454:5;:13;68450:45;;68476:19;;-1:-1:-1;;;68476:19:0;;;;;;;;;;;68450:45;68510:19;68544:17;68564:14;31973:7;32000:13;;31926:95;68564:14;68544:34;-1:-1:-1;78264:1:0;68656:5;:23;68652:87;;;78264:1;68700:23;;68652:87;68815:9;68808:4;:16;68804:73;;;68852:9;68845:16;;68804:73;68891:25;68919:16;68929:5;68919:9;:16::i;:::-;68891:44;;69113:4;69105:5;:12;69101:278;;;69160:12;;;69195:31;;;69191:111;;;69271:11;69251:31;;69191:111;69119:198;69101:278;;;-1:-1:-1;69362:1:0;69101:278;69393:25;69435:17;-1:-1:-1;;;;;69421:32:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69421:32:0;-1:-1:-1;69393:60:0;-1:-1:-1;69472:22:0;69468:78;;69522:8;-1:-1:-1;69515:15:0;;-1:-1:-1;;;69515:15:0;69468:78;69690:31;69724:26;69744:5;69724:19;:26::i;:::-;69690:60;;69765:25;70010:9;:16;;;70005:92;;-1:-1:-1;70067:14:0;;70005:92;70128:5;70111:478;70140:4;70135:1;:9;;:45;;;;;70163:17;70148:11;:32;;70135:45;70111:478;;;70218:15;70231:1;70218:12;:15::i;:::-;70206:27;;70256:9;:16;;;70252:73;;;70297:8;;70252:73;70347:14;;-1:-1:-1;;;;;70347:28:0;;70343:111;;70420:14;;;-1:-1:-1;70343:111:0;70497:5;-1:-1:-1;;;;;70476:26:0;:17;-1:-1:-1;;;;;70476:26:0;;70472:102;;;70553:1;70527:8;70536:13;;;;;;70527:23;;;;;;;;:::i;:::-;;;;;;:27;;;;;70472:102;70182:3;;70111:478;;;-1:-1:-1;;;70674:29:0;;;-1:-1:-1;70681:8:0;;-1:-1:-1;;68261:2505:0;;;;;;:::o;75437:378::-;17006:13;:11;:13::i;:::-;75570:17:::1;;75555:11;75532:20;;:34;;;;:::i;:::-;:55;;75524:95;;;::::0;-1:-1:-1;;;75524:95:0;;13877:2:1;75524:95:0::1;::::0;::::1;13859:21:1::0;13916:2;13896:18;;;13889:30;13955:29;13935:18;;;13928:57;14002:18;;75524:95:0::1;13675:351:1::0;75524:95:0::1;75671:9;;75655:11;75639:13;:11;:13::i;:::-;:27;;;;:::i;:::-;75638:42;;75630:75;;;;-1:-1:-1::0;;;75630:75:0::1;;;;;;;:::i;:::-;75750:11;75726:20;;:35;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;75774:33:0::1;::::0;-1:-1:-1;75784:9:0;75795:11;75774:9:::1;:33::i;41046:308::-:0;-1:-1:-1;;;;;41145:31:0;;61218:10;41145:31;41141:61;;;41185:17;;-1:-1:-1;;;41185:17:0;;;;;;;;;;;41141:61;61218:10;41215:39;;;;:18;:39;;;;;;;;-1:-1:-1;;;;;41215:49:0;;;;;;;;;;;;:60;;-1:-1:-1;;41215:60:0;;;;;;;;;;41291:55;;540:41:1;;;41215:49:0;;61218:10;41291:55;;513:18:1;41291:55:0;;;;;;;41046:308;;:::o;73097:36::-;;;;;;;:::i;77865:111::-;17006:13;:11;:13::i;:::-;77939:20:::1;:29:::0;;;::::1;;;;-1:-1:-1::0;;77939:29:0;;::::1;::::0;;;::::1;::::0;;77865:111::o;41916:399::-;42083:31;42096:4;42102:2;42106:7;42083:12;:31::i;:::-;-1:-1:-1;;;;;42129:14:0;;;:19;42125:183;;42168:56;42199:4;42205:2;42209:7;42218:5;42168:30;:56::i;:::-;42163:145;;42252:40;;-1:-1:-1;;;42252:40:0;;;;;;;;;;;42163:145;41916:399;;;;:::o;66824:420::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78264:1:0;66980:7;:25;:54;;;-1:-1:-1;31973:7:0;32000:13;67009:7;:25;;66980:54;66976:103;;;67058:9;66824:420;-1:-1:-1;;66824:420:0:o;66976:103::-;67101:21;67114:7;67101:12;:21::i;:::-;67089:33;;67137:9;:16;;;67133:65;;;67177:9;66824:420;-1:-1:-1;;66824:420:0:o;67133:65::-;67215:21;67228:7;67215:12;:21::i;76814:108::-;17006:13;:11;:13::i;:::-;76888:17:::1;:26:::0;76814:108::o;75823:473::-;75897:13;75931:17;75939:8;75931:7;:17::i;:::-;75923:77;;;;-1:-1:-1;;;75923:77:0;;14233:2:1;75923:77:0;;;14215:21:1;14272:2;14252:18;;;14245:30;14311:34;14291:18;;;14284:62;-1:-1:-1;;;14362:18:1;;;14355:45;14417:19;;75923:77:0;14031:411:1;75923:77:0;76017:8;;;;;;;76013:74;;76058:17;76051:24;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75823:473;;;:::o;76013:74::-;76099:28;76130:10;:8;:10::i;:::-;76099:41;;76189:1;76164:14;76158:28;:32;:130;;;;;;;;;;;;;;;;;76226:14;76242:19;:8;:17;:19::i;:::-;76263:9;76209:64;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;76151:137;75823:473;-1:-1:-1;;;75823:473:0:o;76395:187::-;17006:13;:11;:13::i;:::-;76505:9:::1;::::0;76484:17:::1;::::0;76475:26:::1;::::0;:6;:26:::1;:::i;:::-;:39;;76467:72;;;;-1:-1:-1::0;;;76467:72:0::1;;;;;;;:::i;:::-;76550:15;:24:::0;76395:187::o;77042:87::-;17006:13;:11;:13::i;:::-;77104:8:::1;:17:::0;;;::::1;;::::0;::::1;-1:-1:-1::0;;77104:17:0;;::::1;::::0;;;::::1;::::0;;77042:87::o;76590:106::-;17006:13;:11;:13::i;:::-;76663:16:::1;:25:::0;76590:106::o;41425:164::-;-1:-1:-1;;;;;41546:25:0;;;41522:4;41546:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;41425:164::o;74413:405::-;74484:11;73343:21;73367:13;:11;:13::i;:::-;73343:37;;73411:15;;73395:13;:31;73391:563;;;73483:1;73469:11;:15;:95;;;;-1:-1:-1;73548:16:0;;61218:10;73505:25;;;;:11;:25;;;;;;:39;;73533:11;;73505:39;:::i;:::-;:59;;73469:95;73443:184;;;;-1:-1:-1;;;73443:184:0;;16307:2:1;73443:184:0;;;16289:21:1;16346:2;16326:18;;;16319:30;16385:29;16365:18;;;16358:57;16432:18;;73443:184:0;16105:351:1;73443:184:0;73391:563;;;73709:1;73695:11;:15;:94;;;;-1:-1:-1;73772:17:0;;73743:10;73731:23;;;;:11;:23;;;;;;:37;;73757:11;;73731:37;:::i;:::-;:58;;73695:94;73669:184;;;;-1:-1:-1;;;73669:184:0;;16663:2:1;73669:184:0;;;16645:21:1;16702:2;16682:18;;;16675:30;16741;16721:18;;;16714:58;16789:18;;73669:184:0;16461:352:1;73669:184:0;73903:15;;73889:29;;:11;:29;:::i;:::-;73876:9;:42;;73868:74;;;;-1:-1:-1;;;73868:74:0;;17193:2:1;73868:74:0;;;17175:21:1;17232:2;17212:18;;;17205:30;-1:-1:-1;;;17251:18:1;;;17244:49;17310:18;;73868:74:0;16991:343:1;73868:74:0;74150:20:::1;::::0;::::1;::::0;::::1;;;:29;74142:57;;;::::0;-1:-1:-1;;;74142:57:0;;17541:2:1;74142:57:0::1;::::0;::::1;17523:21:1::0;17580:2;17560:18;;;17553:30;-1:-1:-1;;;17599:18:1;;;17592:45;17654:18;;74142:57:0::1;17339:339:1::0;74142:57:0::1;74297:9:::2;74310:10;74297:23;74289:61;;;::::0;-1:-1:-1;;;74289:61:0;;17885:2:1;74289:61:0::2;::::0;::::2;17867:21:1::0;17924:2;17904:18;;;17897:30;17963:27;17943:18;;;17936:55;18008:18;;74289:61:0::2;17683:349:1::0;74289:61:0::2;74545:6:::3;::::0;::::3;;74544:7;74536:43;;;::::0;-1:-1:-1;;;74536:43:0;;12910:2:1;74536:43:0::3;::::0;::::3;12892:21:1::0;12949:2;12929:18;;;12922:30;-1:-1:-1;;;12968:18:1;;;12961:53;13031:18;;74536:43:0::3;12708:347:1::0;74536:43:0::3;74662:20;;74642:17;;74630:9;;:29;;;;:::i;:::-;:52;;;;:::i;:::-;74614:11;74598:13;:11;:13::i;:::-;:27;;;;:::i;:::-;:85;;74590:118;;;;-1:-1:-1::0;;;74590:118:0::3;;;;;;;:::i;:::-;61218:10:::0;74721:25:::3;::::0;;;:11:::3;:25;::::0;;;;:40;;74750:11;;74721:25;:40:::3;::::0;74750:11;;74721:40:::3;:::i;:::-;::::0;;;-1:-1:-1;74774:36:0::3;::::0;-1:-1:-1;61218:10:0;74798:11:::3;74774:9;:36::i;18026:201::-:0;17006:13;:11;:13::i;:::-;-1:-1:-1;;;;;18115:22:0;::::1;18107:73;;;::::0;-1:-1:-1;;;18107:73:0;;18239:2:1;18107:73:0::1;::::0;::::1;18221:21:1::0;18278:2;18258:18;;;18251:30;18317:34;18297:18;;;18290:62;-1:-1:-1;;;18368:18:1;;;18361:36;18414:19;;18107:73:0::1;18037:402:1::0;18107:73:0::1;18191:28;18210:8;18191:18;:28::i;:::-;18026:201:::0;:::o;42570:273::-;42627:4;42683:7;78264:1;42664:26;;:66;;;;;42717:13;;42707:7;:23;42664:66;:152;;;;-1:-1:-1;;42768:26:0;;;;:17;:26;;;;;;-1:-1:-1;;;42768:43:0;:48;;42570:273::o;17285:132::-;17193:6;;-1:-1:-1;;;;;17193:6:0;61218:10;17349:23;17341:68;;;;-1:-1:-1;;;17341:68:0;;18646:2:1;17341:68:0;;;18628:21:1;;;18665:18;;;18658:30;18724:34;18704:18;;;18697:62;18776:18;;17341:68:0;18444:356:1;35530:1129:0;35597:7;35632;;78264:1;35681:23;35677:915;;35734:13;;35727:4;:20;35723:869;;;35772:14;35789:23;;;:17;:23;;;;;;-1:-1:-1;;;35878:23:0;;35874:699;;36397:113;36404:11;36397:113;;-1:-1:-1;;;36475:6:0;36457:25;;;;:17;:25;;;;;;36397:113;;35874:699;35749:843;35723:869;36620:31;;-1:-1:-1;;;36620:31:0;;;;;;;;;;;7486:190;7611:4;7664;7635:25;7648:5;7655:4;7635:12;:25::i;:::-;:33;;7486:190;-1:-1:-1;;;;7486:190:0:o;42927:104::-;42996:27;43006:2;43010:8;42996:27;;;;;;;;;;;;:9;:27::i;18387:191::-;18480:6;;;-1:-1:-1;;;;;18497:17:0;;;-1:-1:-1;;;;;;18497:17:0;;;;;;;18530:40;;18480:6;;;18497:17;18480:6;;18530:40;;18461:16;;18530:40;18450:128;18387:191;:::o;37207:153::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37327:24:0;;;;:17;:24;;;;;;37308:44;;:18;:44::i;56786:716::-;56970:88;;-1:-1:-1;;;56970:88:0;;56949:4;;-1:-1:-1;;;;;56970:45:0;;;;;:88;;61218:10;;57037:4;;57043:7;;57052:5;;56970:88;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56970:88:0;;;;;;;;-1:-1:-1;;56970:88:0;;;;;;;;;;;;:::i;:::-;;;56966:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57253:13:0;;57249:235;;57299:40;;-1:-1:-1;;;57299:40:0;;;;;;;;;;;57249:235;57442:6;57436:13;57427:6;57423:2;57419:15;57412:38;56966:529;-1:-1:-1;;;;;;57129:64:0;-1:-1:-1;;;57129:64:0;;-1:-1:-1;56966:529:0;56786:716;;;;;;:::o;37863:158::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37966:47:0;37985:27;38004:7;37985:18;:27::i;:::-;37966:18;:47::i;78281:110::-;78341:13;78374:9;78367:16;;;;;:::i;4200:723::-;4256:13;4477:10;4473:53;;-1:-1:-1;;4504:10:0;;;;;;;;;;;;-1:-1:-1;;;4504:10:0;;;;;4200:723::o;4473:53::-;4551:5;4536:12;4592:78;4599:9;;4592:78;;4625:8;;;;:::i;:::-;;-1:-1:-1;4648:10:0;;-1:-1:-1;4656:2:0;4648:10;;:::i;:::-;;;4592:78;;;4680:19;4712:6;-1:-1:-1;;;;;4702:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4702:17:0;;4680:39;;4730:154;4737:10;;4730:154;;4764:11;4774:1;4764:11;;:::i;:::-;;-1:-1:-1;4833:10:0;4841:2;4833:5;:10;:::i;:::-;4820:24;;:2;:24;:::i;:::-;4807:39;;4790:6;4797;4790:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;4790:56:0;;;;;;;;-1:-1:-1;4861:11:0;4870:2;4861:11;;:::i;:::-;;;4730:154;;8353:296;8436:7;8479:4;8436:7;8494:118;8518:5;:12;8514:1;:16;8494:118;;;8567:33;8577:12;8591:5;8597:1;8591:8;;;;;;;;:::i;:::-;;;;;;;8567:9;:33::i;:::-;8552:48;-1:-1:-1;8532:3:0;;;;:::i;:::-;;;;8494:118;;43447:681;43570:19;43576:2;43580:8;43570:5;:19::i;:::-;-1:-1:-1;;;;;43631:14:0;;;:19;43627:483;;43671:11;43685:13;43733:14;;;43766:233;43797:62;43836:1;43840:2;43844:7;;;;;;43853:5;43797:30;:62::i;:::-;43792:167;;43895:40;;-1:-1:-1;;;43895:40:0;;;;;;;;;;;43792:167;43994:3;43986:5;:11;43766:233;;44081:3;44064:13;;:20;44060:34;;44086:8;;;44060:34;43652:458;;43447:681;;;:::o;36753:363::-;-1:-1:-1;;;;;;;;;;;;;36863:41:0;;;;29065:3;36949:32;;;-1:-1:-1;;;;;36915:67:0;-1:-1:-1;;;36915:67:0;-1:-1:-1;;;37012:23:0;;:28;;-1:-1:-1;;;36993:47:0;;;;29582:3;37080:27;;;;-1:-1:-1;;;37051:57:0;-1:-1:-1;36753:363:0:o;14560:149::-;14623:7;14654:1;14650;:5;:51;;14785:13;14879:15;;;14915:4;14908:15;;;14962:4;14946:21;;14650:51;;;-1:-1:-1;14785:13:0;14879:15;;;14915:4;14908:15;14962:4;14946:21;;;14560:149::o;44401:1529::-;44466:20;44489:13;-1:-1:-1;;;;;44517:16:0;;44513:48;;44542:19;;-1:-1:-1;;;44542:19:0;;;;;;;;;;;44513:48;44576:13;44572:44;;44598:18;;-1:-1:-1;;;44598:18:0;;;;;;;;;;;44572:44;-1:-1:-1;;;;;45104:22:0;;;;;;:18;:22;;28548:2;45104:22;;:70;;45142:31;45130:44;;45104:70;;;38512:11;38488:22;38484:40;-1:-1:-1;40222:15:0;;40197:23;40193:45;38481:51;38471:62;45417:31;;;;:17;:31;;;;;:173;45435:12;45666:23;;;45704:101;45731:35;;45756:9;;;;;-1:-1:-1;;;;;45731:35:0;;;45748:1;;45731:35;;45748:1;;45731:35;45800:3;45790:7;:13;45704:101;;45821:13;:19;-1:-1:-1;41660:185:0;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;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:258::-;664:1;674:113;688:6;685:1;682:13;674:113;;;764:11;;;758:18;745:11;;;738:39;710:2;703:10;674:113;;;805:6;802:1;799:13;796:48;;;-1:-1:-1;;840:1:1;822:16;;815:27;592:258::o;855:::-;897:3;935:5;929:12;962:6;957:3;950:19;978:63;1034:6;1027:4;1022:3;1018:14;1011:4;1004:5;1000:16;978:63;:::i;:::-;1095:2;1074:15;-1:-1:-1;;1070:29:1;1061:39;;;;1102:4;1057:50;;855:258;-1:-1:-1;;855:258:1:o;1118:220::-;1267:2;1256:9;1249:21;1230:4;1287:45;1328:2;1317:9;1313:18;1305:6;1287:45;:::i;1343:180::-;1402:6;1455:2;1443:9;1434:7;1430:23;1426:32;1423:52;;;1471:1;1468;1461:12;1423:52;-1:-1:-1;1494:23:1;;1343:180;-1:-1:-1;1343:180:1:o;1736:173::-;1804:20;;-1:-1:-1;;;;;1853:31:1;;1843:42;;1833:70;;1899:1;1896;1889:12;1833:70;1736:173;;;:::o;1914:254::-;1982:6;1990;2043:2;2031:9;2022:7;2018:23;2014:32;2011:52;;;2059:1;2056;2049:12;2011:52;2082:29;2101:9;2082:29;:::i;:::-;2072:39;2158:2;2143:18;;;;2130:32;;-1:-1:-1;;;1914:254:1:o;2355:127::-;2416:10;2411:3;2407:20;2404:1;2397:31;2447:4;2444:1;2437:15;2471:4;2468:1;2461:15;2487:275;2558:2;2552:9;2623:2;2604:13;;-1:-1:-1;;2600:27:1;2588:40;;-1:-1:-1;;;;;2643:34:1;;2679:22;;;2640:62;2637:88;;;2705:18;;:::i;:::-;2741:2;2734:22;2487:275;;-1:-1:-1;2487:275:1:o;2767:407::-;2832:5;-1:-1:-1;;;;;2858:6:1;2855:30;2852:56;;;2888:18;;:::i;:::-;2926:57;2971:2;2950:15;;-1:-1:-1;;2946:29:1;2977:4;2942:40;2926:57;:::i;:::-;2917:66;;3006:6;2999:5;2992:21;3046:3;3037:6;3032:3;3028:16;3025:25;3022:45;;;3063:1;3060;3053:12;3022:45;3112:6;3107:3;3100:4;3093:5;3089:16;3076:43;3166:1;3159:4;3150:6;3143:5;3139:18;3135:29;3128:40;2767:407;;;;;:::o;3179:451::-;3248:6;3301:2;3289:9;3280:7;3276:23;3272:32;3269:52;;;3317:1;3314;3307:12;3269:52;3357:9;3344:23;-1:-1:-1;;;;;3382:6:1;3379:30;3376:50;;;3422:1;3419;3412:12;3376:50;3445:22;;3498:4;3490:13;;3486:27;-1:-1:-1;3476:55:1;;3527:1;3524;3517:12;3476:55;3550:74;3616:7;3611:2;3598:16;3593:2;3589;3585:11;3550:74;:::i;3635:160::-;3700:20;;3756:13;;3749:21;3739:32;;3729:60;;3785:1;3782;3775:12;3800:180;3856:6;3909:2;3897:9;3888:7;3884:23;3880:32;3877:52;;;3925:1;3922;3915:12;3877:52;3948:26;3964:9;3948:26;:::i;3985:186::-;4044:6;4097:2;4085:9;4076:7;4072:23;4068:32;4065:52;;;4113:1;4110;4103:12;4065:52;4136:29;4155:9;4136:29;:::i;4176:328::-;4253:6;4261;4269;4322:2;4310:9;4301:7;4297:23;4293:32;4290:52;;;4338:1;4335;4328:12;4290:52;4361:29;4380:9;4361:29;:::i;:::-;4351:39;;4409:38;4443:2;4432:9;4428:18;4409:38;:::i;:::-;4399:48;;4494:2;4483:9;4479:18;4466:32;4456:42;;4176:328;;;;;:::o;4691:615::-;4777:6;4785;4838:2;4826:9;4817:7;4813:23;4809:32;4806:52;;;4854:1;4851;4844:12;4806:52;4894:9;4881:23;-1:-1:-1;;;;;4964:2:1;4956:6;4953:14;4950:34;;;4980:1;4977;4970:12;4950:34;5018:6;5007:9;5003:22;4993:32;;5063:7;5056:4;5052:2;5048:13;5044:27;5034:55;;5085:1;5082;5075:12;5034:55;5125:2;5112:16;5151:2;5143:6;5140:14;5137:34;;;5167:1;5164;5157:12;5137:34;5220:7;5215:2;5205:6;5202:1;5198:14;5194:2;5190:23;5186:32;5183:45;5180:65;;;5241:1;5238;5231:12;5180:65;5272:2;5264:11;;;;;5294:6;;-1:-1:-1;4691:615:1;;-1:-1:-1;;;;4691:615:1:o;5311:946::-;5395:6;5426:2;5469;5457:9;5448:7;5444:23;5440:32;5437:52;;;5485:1;5482;5475:12;5437:52;5525:9;5512:23;-1:-1:-1;;;;;5595:2:1;5587:6;5584:14;5581:34;;;5611:1;5608;5601:12;5581:34;5649:6;5638:9;5634:22;5624:32;;5694:7;5687:4;5683:2;5679:13;5675:27;5665:55;;5716:1;5713;5706:12;5665:55;5752:2;5739:16;5774:2;5770;5767:10;5764:36;;;5780:18;;:::i;:::-;5826:2;5823:1;5819:10;5809:20;;5849:28;5873:2;5869;5865:11;5849:28;:::i;:::-;5911:15;;;5981:11;;;5977:20;;;5942:12;;;;6009:19;;;6006:39;;;6041:1;6038;6031:12;6006:39;6065:11;;;;6085:142;6101:6;6096:3;6093:15;6085:142;;;6167:17;;6155:30;;6118:12;;;;6205;;;;6085:142;;;6246:5;5311:946;-1:-1:-1;;;;;;;;5311:946:1:o;6262:349::-;6346:12;;-1:-1:-1;;;;;6342:38:1;6330:51;;6434:4;6423:16;;;6417:23;-1:-1:-1;;;;;6413:48:1;6397:14;;;6390:72;6525:4;6514:16;;;6508:23;6501:31;6494:39;6478:14;;;6471:63;6587:4;6576:16;;;6570:23;6595:8;6566:38;6550:14;;6543:62;6262:349::o;6616:722::-;6849:2;6901:21;;;6971:13;;6874:18;;;6993:22;;;6820:4;;6849:2;7072:15;;;;7046:2;7031:18;;;6820:4;7115:197;7129:6;7126:1;7123:13;7115:197;;;7178:52;7226:3;7217:6;7211:13;7178:52;:::i;:::-;7287:15;;;;7259:4;7250:14;;;;;7151:1;7144:9;7115:197;;7528:632;7699:2;7751:21;;;7821:13;;7724:18;;;7843:22;;;7670:4;;7699:2;7922:15;;;;7896:2;7881:18;;;7670:4;7965:169;7979:6;7976:1;7973:13;7965:169;;;8040:13;;8028:26;;8109:15;;;;8074:12;;;;8001:1;7994:9;7965:169;;8165:322;8242:6;8250;8258;8311:2;8299:9;8290:7;8286:23;8282:32;8279:52;;;8327:1;8324;8317:12;8279:52;8350:29;8369:9;8350:29;:::i;:::-;8340:39;8426:2;8411:18;;8398:32;;-1:-1:-1;8477:2:1;8462:18;;;8449:32;;8165:322;-1:-1:-1;;;8165:322:1:o;8492:254::-;8560:6;8568;8621:2;8609:9;8600:7;8596:23;8592:32;8589:52;;;8637:1;8634;8627:12;8589:52;8673:9;8660:23;8650:33;;8702:38;8736:2;8725:9;8721:18;8702:38;:::i;:::-;8692:48;;8492:254;;;;;:::o;8751:::-;8816:6;8824;8877:2;8865:9;8856:7;8852:23;8848:32;8845:52;;;8893:1;8890;8883:12;8845:52;8916:29;8935:9;8916:29;:::i;:::-;8906:39;;8964:35;8995:2;8984:9;8980:18;8964:35;:::i;9010:667::-;9105:6;9113;9121;9129;9182:3;9170:9;9161:7;9157:23;9153:33;9150:53;;;9199:1;9196;9189:12;9150:53;9222:29;9241:9;9222:29;:::i;:::-;9212:39;;9270:38;9304:2;9293:9;9289:18;9270:38;:::i;:::-;9260:48;;9355:2;9344:9;9340:18;9327:32;9317:42;;9410:2;9399:9;9395:18;9382:32;-1:-1:-1;;;;;9429:6:1;9426:30;9423:50;;;9469:1;9466;9459:12;9423:50;9492:22;;9545:4;9537:13;;9533:27;-1:-1:-1;9523:55:1;;9574:1;9571;9564:12;9523:55;9597:74;9663:7;9658:2;9645:16;9640:2;9636;9632:11;9597:74;:::i;:::-;9587:84;;;9010:667;;;;;;;:::o;9682:266::-;9878:3;9863:19;;9891:51;9867:9;9924:6;9891:51;:::i;9953:260::-;10021:6;10029;10082:2;10070:9;10061:7;10057:23;10053:32;10050:52;;;10098:1;10095;10088:12;10050:52;10121:29;10140:9;10121:29;:::i;:::-;10111:39;;10169:38;10203:2;10192:9;10188:18;10169:38;:::i;10218:380::-;10297:1;10293:12;;;;10340;;;10361:61;;10415:4;10407:6;10403:17;10393:27;;10361:61;10468:2;10460:6;10457:14;10437:18;10434:38;10431:161;;;10514:10;10509:3;10505:20;10502:1;10495:31;10549:4;10546:1;10539:15;10577:4;10574:1;10567:15;10431:161;;10218:380;;;:::o;10603:127::-;10664:10;10659:3;10655:20;10652:1;10645:31;10695:4;10692:1;10685:15;10719:4;10716:1;10709:15;10735:125;10775:4;10803:1;10800;10797:8;10794:34;;;10808:18;;:::i;:::-;-1:-1:-1;10845:9:1;;10735:125::o;10865:344::-;11067:2;11049:21;;;11106:2;11086:18;;;11079:30;-1:-1:-1;;;11140:2:1;11125:18;;11118:50;11200:2;11185:18;;10865:344::o;13410:128::-;13450:3;13481:1;13477:6;13474:1;13471:13;13468:39;;;13487:18;;:::i;:::-;-1:-1:-1;13523:9:1;;13410:128::o;13543:127::-;13604:10;13599:3;13595:20;13592:1;13585:31;13635:4;13632:1;13625:15;13659:4;13656:1;13649:15;14573:1527;14797:3;14835:6;14829:13;14861:4;14874:51;14918:6;14913:3;14908:2;14900:6;14896:15;14874:51;:::i;:::-;14988:13;;14947:16;;;;15010:55;14988:13;14947:16;15032:15;;;15010:55;:::i;:::-;15154:13;;15087:20;;;15127:1;;15214;15236:18;;;;15289;;;;15316:93;;15394:4;15384:8;15380:19;15368:31;;15316:93;15457:2;15447:8;15444:16;15424:18;15421:40;15418:167;;;-1:-1:-1;;;15484:33:1;;15540:4;15537:1;15530:15;15570:4;15491:3;15558:17;15418:167;15601:18;15628:110;;;;15752:1;15747:328;;;;15594:481;;15628:110;-1:-1:-1;;15663:24:1;;15649:39;;15708:20;;;;-1:-1:-1;15628:110:1;;15747:328;14520:1;14513:14;;;14557:4;14544:18;;15842:1;15856:169;15870:8;15867:1;15864:15;15856:169;;;15952:14;;15937:13;;;15930:37;15995:16;;;;15887:10;;15856:169;;;15860:3;;16056:8;16049:5;16045:20;16038:27;;15594:481;-1:-1:-1;16091:3:1;;14573:1527;-1:-1:-1;;;;;;;;;;;14573:1527:1:o;16818:168::-;16858:7;16924:1;16920;16916:6;16912:14;16909:1;16906:21;16901:1;16894:9;16887:17;16883:45;16880:71;;;16931:18;;:::i;:::-;-1:-1:-1;16971:9:1;;16818:168::o;18805:489::-;-1:-1:-1;;;;;19074:15:1;;;19056:34;;19126:15;;19121:2;19106:18;;19099:43;19173:2;19158:18;;19151:34;;;19221:3;19216:2;19201:18;;19194:31;;;18999:4;;19242:46;;19268:19;;19260:6;19242:46;:::i;:::-;19234:54;18805:489;-1:-1:-1;;;;;;18805:489:1:o;19299:249::-;19368:6;19421:2;19409:9;19400:7;19396:23;19392:32;19389:52;;;19437:1;19434;19427:12;19389:52;19469:9;19463:16;19488:30;19512:5;19488:30;:::i;19553:135::-;19592:3;-1:-1:-1;;19613:17:1;;19610:43;;;19633:18;;:::i;:::-;-1:-1:-1;19680:1:1;19669:13;;19553:135::o;19693:127::-;19754:10;19749:3;19745:20;19742:1;19735:31;19785:4;19782:1;19775:15;19809:4;19806:1;19799:15;19825:120;19865:1;19891;19881:35;;19896:18;;:::i;:::-;-1:-1:-1;19930:9:1;;19825:120::o;19950:112::-;19982:1;20008;19998:35;;20013:18;;:::i;:::-;-1:-1:-1;20047:9:1;;19950:112::o

Swarm Source

ipfs://e8df2bb1cdefc043df9fb8a6c1d7e024e5204f9e023f3f04c670f5057adff0b8

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.