Token

Gods Clash (GCLASH)

ERC-721

Overview

Max Total Supply

9,513 GCLASH

Holders

2,251

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x07c453bc0462bd2e24cb475893174b40e29f44e0

Filtered by Token Holder

0x6cc4774CF4d4c738e3310F1b210c6FfE23d93999

innamodja.eth

Balance

5 GCLASH

0x6cc4774cf4d4c738e3310f1b210c6ffe23d93999

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

GodsClash

Compiler Version

v0.8.4+commit.c7e474f2

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

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

// 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/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/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/extensions/IERC721ABurnable.sol


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

pragma solidity ^0.8.4;


/**
 * @dev Interface of an ERC721ABurnable compliant contract.
 */
interface IERC721ABurnable is IERC721A {
    /**
     * @dev Burns `tokenId`. See {ERC721A-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) external;
}

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


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

pragma solidity ^0.8.4;



/**
 * @title ERC721A Burnable Token
 * @dev ERC721A Token that can be irreversibly burned (destroyed).
 */
abstract contract ERC721ABurnable is ERC721A, IERC721ABurnable {
    /**
     * @dev Burns `tokenId`. See {ERC721A-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual override {
        _burn(tokenId, true);
    }
}

// File: contracts/GodsClash.sol



pragma solidity ^0.8.4;






contract GodsClash is ERC721ABurnable, Ownable {

    uint256 private MAX_SUPPLY = 10000;

    // Public mint
    uint256 public publicMaxPerTransaction = 5;

    // Whitelist
    uint256 public whitelistMaxPerWallet = 1;
    bool public whitelistActive = false;
    bytes32 private merkleRoot;
    mapping(address => uint256) private whitelistMinted;

    string private _baseURIextended;
    bool public publicSaleIsActive = false;
    bool public burningActive = false;

    // Revealing
    string private hiddenMetadataUri;
    bool public revealed = false;

    // Reserve
    uint256 public reservedAmount = 500;

    constructor(
        string memory name,
        string memory symbol,
        string memory _hiddenMetadataUri,
        string memory _uriExtended,
        bytes32 _merkleRoot
    ) ERC721A(name, symbol) {
        hiddenMetadataUri = _hiddenMetadataUri;
        _baseURIextended = _uriExtended;
        merkleRoot = _merkleRoot;
    }

    /**************************
    *         Public
    /**************************/

    function mintFromWhiteList(uint8 numberOfTokens, bytes32[] memory proof) external {
        require(whitelistActive, "Whitelist is not active");
        require(numberOfTokens > 0, "Must mint at least one token");
        require(numberOfTokens <= availableSupply(), "Purchase would exceed token supply");
        require(isWhitelisted(proof, msg.sender), "Invalid proof");
        require(whitelistMinted[msg.sender] + numberOfTokens <= whitelistMaxPerWallet, "Exceed max per wallet");

        whitelistMinted[msg.sender] += numberOfTokens;

        _safeMint(msg.sender, numberOfTokens);
    }

    function mint(uint numberOfTokens) external {
        require(publicSaleIsActive, "Public sale must be active to mint tokens");
        require(numberOfTokens > 0, "Must mint at least one token");
        require(numberOfTokens <= availableSupply(), "Purchase would exceed token supply");
        require(numberOfTokens <= publicMaxPerTransaction, "Exceed max per transaction");

        _safeMint(msg.sender, numberOfTokens);
    }

    function canMint(address addr, bytes32[] memory proof) external view returns (bool) {

        if(whitelistActive && isWhitelisted(proof, msg.sender))
        {
            return whitelistMinted[addr] < whitelistMaxPerWallet;
        }

        return publicSaleIsActive;
    }

    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "This token doesn't exist");

        if(revealed == false)
        {
            return bytes(hiddenMetadataUri).length > 0 ? string(abi.encodePacked(hiddenMetadataUri, Strings.toString(tokenId), ".json")) : "";
        }

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

    function availableSupply() public view returns (uint256)
    {
        return MAX_SUPPLY - (reservedAmount + _totalMinted());
    }

    function isWhitelisted(bytes32[] memory proof, address addr) public view returns(bool)
    {
        bytes32 leaf = keccak256(abi.encodePacked(addr));

        return MerkleProof.verify(proof, merkleRoot, leaf);
    }

    function burn(uint256 tokenId) public virtual override {
        require(burningActive, "Burning is not active");

        _burn(tokenId, true);
    }

    /**************************
    *         Only Owner
    /**************************/

    function setWhitelistActive(bool value) external onlyOwner {
        whitelistActive = value;
    }

    function setPublicSaleState(bool value) external onlyOwner {
        publicSaleIsActive = value;
    }

    function setBurningActive(bool value) external onlyOwner {
        burningActive = value;
    }

    function setPublicMaxPerTransaction(uint256 value) external onlyOwner {
        publicMaxPerTransaction = value;
    }

    function setReservedAmount(uint256 _setReservedAmount) external onlyOwner {
        require(_totalMinted() + _setReservedAmount <= MAX_SUPPLY, "There are no enough tokens left");

        reservedAmount = _setReservedAmount;
    }

    function setRevealed(bool value) external onlyOwner {
        revealed = value;
    }

    function sethiddenMetadataUri(string memory _hiddenMetadataUri) external onlyOwner() {
        hiddenMetadataUri = _hiddenMetadataUri;
    }

    function setBaseURI(string memory _uri) external onlyOwner() {
        _baseURIextended = _uri;
    }

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

    function mintFromReserve(address addr, uint256 numberOfTokens) external onlyOwner {
        require(numberOfTokens <= reservedAmount, "There are no enough tokens left in the reserve");
        require(numberOfTokens > 0, "Must mint at least one token");

        reservedAmount -= numberOfTokens;

        _safeMint(addr, numberOfTokens);
    }

    function withdraw() external onlyOwner {
        uint balance = address(this).balance;
        payable(msg.sender).transfer(balance);
    }

    /**************************
    *         Internal
    /**************************/

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

    function _startTokenId() internal view virtual override returns (uint256) {
        return 1;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"string","name":"_hiddenMetadataUri","type":"string"},{"internalType":"string","name":"_uriExtended","type":"string"},{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"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":"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":[],"name":"availableSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"burningActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"canMint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"address","name":"addr","type":"address"}],"name":"isWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"mintFromReserve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"numberOfTokens","type":"uint8"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"mintFromWhiteList","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":"publicMaxPerTransaction","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSaleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reservedAmount","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":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uri","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"value","type":"bool"}],"name":"setBurningActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"setPublicMaxPerTransaction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"value","type":"bool"}],"name":"setPublicSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_setReservedAmount","type":"uint256"}],"name":"setReservedAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"value","type":"bool"}],"name":"setRevealed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"value","type":"bool"}],"name":"setWhitelistActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_hiddenMetadataUri","type":"string"}],"name":"sethiddenMetadataUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"whitelistActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistMaxPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000018065dbc10aa427082bc6e79737022ffea1449d27c1e6509954667ea8516cd25ac3000000000000000000000000000000000000000000000000000000000000000a476f647320436c61736800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000647434c4153480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002568747470733a2f2f676f6473636c6173682e696f2f68696464656e5f6d657461646174612f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012300000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): Gods Clash
Arg [1] : symbol (string): GCLASH
Arg [2] : _hiddenMetadataUri (string): https://godsclash.io/hidden_metadata/
Arg [3] : _uriExtended (string): #
Arg [4] : _merkleRoot (bytes32): 0x65dbc10aa427082bc6e79737022ffea1449d27c1e6509954667ea8516cd25ac3

-----Encoded View---------------
14 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000180
Arg [4] : 65dbc10aa427082bc6e79737022ffea1449d27c1e6509954667ea8516cd25ac3
Arg [5] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [6] : 476f647320436c61736800000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [8] : 47434c4153480000000000000000000000000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000025
Arg [10] : 68747470733a2f2f676f6473636c6173682e696f2f68696464656e5f6d657461
Arg [11] : 646174612f000000000000000000000000000000000000000000000000000000
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [13] : 2300000000000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

60710:5617:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29894:615;;;;;;:::i;:::-;;:::i;:::-;;;10224:14:1;;10217:22;10199:41;;10187:2;10172:18;29894:615:0;;;;;;;;60945:35;;;;;;;;;35541:100;;;:::i;:::-;;;;;;;:::i;37487:204::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;9522:32:1;;;9504:51;;9492:2;9477:18;37487:204:0;9459:102:1;37035:386:0;;;;;;:::i;:::-;;:::i;:::-;;61118:38;;;;;;;;;64775:234;;;;;;:::i;:::-;;:::i;28948:315::-;66315:1;29214:12;29001:7;29198:13;:28;-1:-1:-1;;29198:46:0;28948:315;;;15436:25:1;;;15424:2;15409:18;28948:315:0;15391:76:1;61163:33:0;;;;;;;;;;;;46752:2800;;;;;;:::i;:::-;;:::i;65848:142::-;;;:::i;38377:185::-;;;;;;:::i;:::-;;:::i;64064:154::-;;;;;;:::i;:::-;;:::i;61262:28::-;;;;;;;;;65262:103;;;;;;:::i;:::-;;:::i;35330:144::-;;;;;;:::i;:::-;;:::i;30573:224::-;;;;;;:::i;:::-;;:::i;13998:103::-;;;:::i;65373:108::-;;;;;;:::i;:::-;;:::i;63692:134::-;;;:::i;13350:87::-;13423:6;;-1:-1:-1;;;;;13423:6:0;13350:87;;64430:104;;;;;;:::i;:::-;;:::i;35710:::-;;;:::i;60829:42::-;;;;;;65489:351;;;;;;:::i;:::-;;:::i;62417:439::-;;;;;;:::i;:::-;;:::i;37763:308::-;;;;;;:::i;:::-;;:::i;64647:120::-;;;;;;:::i;:::-;;:::i;65112:142::-;;;;;;:::i;:::-;;:::i;38633:399::-;;;;;;:::i;:::-;;:::i;64321:101::-;;;;;;:::i;:::-;;:::i;64542:97::-;;;;;;:::i;:::-;;:::i;63158:526::-;;;;;;:::i;:::-;;:::i;62864:286::-;;;;;;:::i;:::-;;:::i;63834:222::-;;;;;;:::i;:::-;;:::i;65017:87::-;;;;;;:::i;:::-;;:::i;61803:606::-;;;;;;:::i;:::-;;:::i;38142:164::-;;;;;;:::i;:::-;-1:-1:-1;;;;;38263:25:0;;;38239:4;38263:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;38142:164;14256:201;;;;;;:::i;:::-;;:::i;60898:40::-;;;;;;61315:35;;;;;;29894:615;29979:4;-1:-1:-1;;;;;;;;;30279:25:0;;;;:102;;-1:-1:-1;;;;;;;;;;30356:25:0;;;30279:102;:179;;;-1:-1:-1;;;;;;;;;;30433:25:0;;;30279:179;30259:199;29894:615;-1:-1:-1;;29894:615:0:o;35541:100::-;35595:13;35628:5;35621:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35541:100;:::o;37487:204::-;37555:7;37580:16;37588:7;37580;:16::i;:::-;37575:64;;37605:34;;-1:-1:-1;;;37605:34:0;;;;;;;;;;;37575:64;-1:-1:-1;37659:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;37659:24:0;;37487:204::o;37035:386::-;37108:13;37124:16;37132:7;37124;:16::i;:::-;37108:32;-1:-1:-1;57935:10:0;-1:-1:-1;;;;;37157:28:0;;;37153:175;;37205:44;37222:5;57935:10;38142:164;:::i;37205:44::-;37200:128;;37277:35;;-1:-1:-1;;;37277:35:0;;;;;;;;;;;37200:128;37340:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;37340:29:0;-1:-1:-1;;;;;37340:29:0;;;;;;;;;37385:28;;37340:24;;37385:28;;;;;;;37035:386;;;:::o;64775:234::-;13236:13;:11;:13::i;:::-;64907:10:::1;;64885:18;64868:14;29408:7:::0;29596:13;-1:-1:-1;;29596:31:0;;29361:285;64868:14:::1;:35;;;;:::i;:::-;:49;;64860:93;;;::::0;-1:-1:-1;;;64860:93:0;;15132:2:1;64860:93:0::1;::::0;::::1;15114:21:1::0;15171:2;15151:18;;;15144:30;15210:33;15190:18;;;15183:61;15261:18;;64860:93:0::1;;;;;;;;;64966:14;:35:::0;64775:234::o;46752:2800::-;46886:27;46916;46935:7;46916:18;:27::i;:::-;46886:57;;47001:4;-1:-1:-1;;;;;46960:45:0;46976:19;-1:-1:-1;;;;;46960:45:0;;46956:86;;47014:28;;-1:-1:-1;;;47014:28:0;;;;;;;;;;;46956:86;47056:27;45482:21;;;45309:15;45524:4;45517:36;45606:4;45590:21;;45696:26;;47240:62;45696:26;47276:4;57935:10;47282:19;-1:-1:-1;;;;;46301:31:0;;;46147:26;;46428:19;;46449:30;;46425:55;;46028:463;47240:62;47235:174;;47322:43;47339:4;57935:10;38142:164;:::i;47322:43::-;47317:92;;47374:35;;-1:-1:-1;;;47374:35:0;;;;;;;;;;;47317:92;-1:-1:-1;;;;;47426:16:0;;47422:52;;47451:23;;-1:-1:-1;;;47451:23:0;;;;;;;;;;;47422:52;47623:15;47620:2;;;47763:1;47742:19;47735:30;47620:2;-1:-1:-1;;;;;48158:24:0;;;;;;;:18;:24;;;;;;48156:26;;-1:-1:-1;;48156:26:0;;;48227:22;;;;;;;;;48225:24;;-1:-1:-1;48225:24:0;;;35229:11;35205:22;35201:40;35188:62;-1:-1:-1;;;35188:62:0;48520:26;;;;:17;:26;;;;;:174;-1:-1:-1;;;48814:46:0;;48810:626;;48918:1;48908:11;;48886:19;49041:30;;;:17;:30;;;;;;49037:384;;49179:13;;49164:11;:28;49160:242;;49326:30;;;;:17;:30;;;;;:52;;;49160:242;48810:626;;49483:7;49479:2;-1:-1:-1;;;;;49464:27:0;49473:4;-1:-1:-1;;;;;49464:27:0;;;;;;;;;;;46752:2800;;;;;;:::o;65848:142::-;13236:13;:11;:13::i;:::-;65945:37:::1;::::0;65913:21:::1;::::0;65953:10:::1;::::0;65945:37;::::1;;;::::0;65913:21;;65898:12:::1;65945:37:::0;65898:12;65945:37;65913:21;65953:10;65945:37;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;13260:1;65848:142::o:0;38377:185::-;38515:39;38532:4;38538:2;38542:7;38515:39;;;;;;;;;;;;:16;:39::i;:::-;38377:185;;;:::o;64064:154::-;64138:13;;;;;;;64130:47;;;;-1:-1:-1;;;64130:47:0;;12196:2:1;64130:47:0;;;12178:21:1;12235:2;12215:18;;;12208:30;-1:-1:-1;;;12254:18:1;;;12247:51;12315:18;;64130:47:0;12168:171:1;64130:47:0;64190:20;64196:7;64205:4;64190:5;:20::i;:::-;64064:154;:::o;65262:103::-;13236:13;:11;:13::i;:::-;65334:23;;::::1;::::0;:16:::1;::::0;:23:::1;::::0;::::1;::::0;::::1;:::i;35330:144::-:0;35394:7;35437:27;35456:7;35437:18;:27::i;30573:224::-;30637:7;-1:-1:-1;;;;;30661:19:0;;30657:60;;30689:28;;-1:-1:-1;;;30689:28:0;;;;;;;;;;;30657:60;-1:-1:-1;;;;;;30735:25:0;;;;;:18;:25;;;;;;25128:13;30735:54;;30573:224::o;13998:103::-;13236:13;:11;:13::i;:::-;14063:30:::1;14090:1;14063:18;:30::i;:::-;13998:103::o:0;65373:108::-;13236:13;:11;:13::i;:::-;65449:10:::1;:24:::0;65373:108::o;63692:134::-;63740:7;29596:13;;-1:-1:-1;;29596:31:0;63786:14;;:31;;;;:::i;:::-;63772:10;;:46;;;;:::i;:::-;63765:53;;63692:134;:::o;64430:104::-;13236:13;:11;:13::i;:::-;64500:18:::1;:26:::0;;-1:-1:-1;;64500:26:0::1;::::0;::::1;;::::0;;;::::1;::::0;;64430:104::o;35710:::-;35766:13;35799:7;35792:14;;;;;:::i;65489:351::-;13236:13;:11;:13::i;:::-;65608:14:::1;;65590;:32;;65582:91;;;::::0;-1:-1:-1;;;65582:91:0;;14022:2:1;65582:91:0::1;::::0;::::1;14004:21:1::0;14061:2;14041:18;;;14034:30;14100:34;14080:18;;;14073:62;-1:-1:-1;;;14151:18:1;;;14144:44;14205:19;;65582:91:0::1;13994:236:1::0;65582:91:0::1;65709:1;65692:14;:18;65684:59;;;;-1:-1:-1::0;;;65684:59:0::1;;;;;;;:::i;:::-;65774:14;65756;;:32;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;65801:31:0::1;::::0;-1:-1:-1;65811:4:0;65817:14;65801:9:::1;:31::i;62417:439::-:0;62480:18;;;;62472:72;;;;-1:-1:-1;;;62472:72:0;;11786:2:1;62472:72:0;;;11768:21:1;11825:2;11805:18;;;11798:30;11864:34;11844:18;;;11837:62;-1:-1:-1;;;11915:18:1;;;11908:39;11964:19;;62472:72:0;11758:231:1;62472:72:0;62580:1;62563:14;:18;62555:59;;;;-1:-1:-1;;;62555:59:0;;;;;;;:::i;:::-;62651:17;:15;:17::i;:::-;62633:14;:35;;62625:82;;;;-1:-1:-1;;;62625:82:0;;;;;;;:::i;:::-;62744:23;;62726:14;:41;;62718:80;;;;-1:-1:-1;;;62718:80:0;;12546:2:1;62718:80:0;;;12528:21:1;12585:2;12565:18;;;12558:30;12624:28;12604:18;;;12597:56;12670:18;;62718:80:0;12518:176:1;62718:80:0;62811:37;62821:10;62833:14;62811:9;:37::i;37763:308::-;-1:-1:-1;;;;;37862:31:0;;57935:10;37862:31;37858:61;;;37902:17;;-1:-1:-1;;;37902:17:0;;;;;;;;;;;37858:61;57935:10;37932:39;;;;:18;:39;;;;;;;;-1:-1:-1;;;;;37932:49:0;;;;;;;;;;;;:60;;-1:-1:-1;;37932:60:0;;;;;;;;;;38008:55;;10199:41:1;;;37932:49:0;;57935:10;38008:55;;10172:18:1;38008:55:0;;;;;;;37763:308;;:::o;64647:120::-;13236:13;:11;:13::i;:::-;64728:23:::1;:31:::0;64647:120::o;65112:142::-;13236:13;:11;:13::i;:::-;65208:38;;::::1;::::0;:17:::1;::::0;:38:::1;::::0;::::1;::::0;::::1;:::i;38633:399::-:0;38800:31;38813:4;38819:2;38823:7;38800:12;:31::i;:::-;-1:-1:-1;;;;;38846:14:0;;;:19;38842:183;;38885:56;38916:4;38922:2;38926:7;38935:5;38885:30;:56::i;:::-;38880:145;;38969:40;;-1:-1:-1;;;38969:40:0;;;;;;;;;;;38880:145;38633:399;;;;:::o;64321:101::-;13236:13;:11;:13::i;:::-;64391:15:::1;:23:::0;;-1:-1:-1;;64391:23:0::1;::::0;::::1;;::::0;;;::::1;::::0;;64321:101::o;64542:97::-;13236:13;:11;:13::i;:::-;64610::::1;:21:::0;;;::::1;;;;-1:-1:-1::0;;64610:21:0;;::::1;::::0;;;::::1;::::0;;64542:97::o;63158:526::-;63231:13;63265:16;63273:7;63265;:16::i;:::-;63257:53;;;;-1:-1:-1;;;63257:53:0;;14779:2:1;63257:53:0;;;14761:21:1;14818:2;14798:18;;;14791:30;14857:26;14837:18;;;14830:54;14901:18;;63257:53:0;14751:174:1;63257:53:0;63326:8;;;;63323:187;;63410:1;63382:17;63376:31;;;;;:::i;:::-;;;:35;:122;;;;;;;;;;;;;;;;;63438:17;63457:25;63474:7;63457:16;:25::i;:::-;63421:71;;;;;;;;;:::i;:::-;;;;;;;;;;;;;63369:129;63158:526;-1:-1:-1;;63158:526:0:o;63323:187::-;63522:21;63546:10;:8;:10::i;:::-;63522:34;;63598:1;63580:7;63574:21;:25;:102;;;;;;;;;;;;;;;;;63626:7;63635:25;63652:7;63635:16;:25::i;:::-;63609:61;;;;;;;;;:::i;:::-;;;;;;;;;;;;;63574:102;63567:109;63158:526;-1:-1:-1;;;63158:526:0:o;62864:286::-;62964:15;;62942:4;;62964:15;;:51;;;;;62983:32;62997:5;63004:10;62983:13;:32::i;:::-;62961:144;;;-1:-1:-1;63072:21:0;;-1:-1:-1;;;;;63048:21:0;;;;;;:15;:21;;;;;;:45;63041:52;;62961:144;-1:-1:-1;63124:18:0;;;;62864:286;;;;:::o;63834:222::-;63962:22;;-1:-1:-1;;7321:2:1;7317:15;;;7313:53;63962:22:0;;;7301:66:1;63915:4:0;;;;7383:12:1;;63962:22:0;;;;;;;;;;;;63952:33;;;;;;63937:48;;64005:43;64024:5;64031:10;;64043:4;64005:18;:43::i;:::-;63998:50;63834:222;-1:-1:-1;;;;63834:222:0:o;65017:87::-;13236:13;:11;:13::i;:::-;65080:8:::1;:16:::0;;-1:-1:-1;;65080:16:0::1;::::0;::::1;;::::0;;;::::1;::::0;;65017:87::o;61803:606::-;61904:15;;;;61896:51;;;;-1:-1:-1;;;61896:51:0;;10677:2:1;61896:51:0;;;10659:21:1;10716:2;10696:18;;;10689:30;10755:25;10735:18;;;10728:53;10798:18;;61896:51:0;10649:173:1;61896:51:0;61983:1;61966:14;:18;;;61958:59;;;;-1:-1:-1;;;61958:59:0;;;;;;;:::i;:::-;62054:17;:15;:17::i;:::-;62036:14;:35;;;;62028:82;;;;-1:-1:-1;;;62028:82:0;;;;;;;:::i;:::-;62129:32;62143:5;62150:10;62129:13;:32::i;:::-;62121:58;;;;-1:-1:-1;;;62121:58:0;;14437:2:1;62121:58:0;;;14419:21:1;14476:2;14456:18;;;14449:30;-1:-1:-1;;;14495:18:1;;;14488:43;14548:18;;62121:58:0;14409:163:1;62121:58:0;62246:21;;62214:10;62198:27;;;;:15;:27;;;;;;:44;;;;;;;:::i;:::-;:69;;62190:103;;;;-1:-1:-1;;;62190:103:0;;11436:2:1;62190:103:0;;;11418:21:1;11475:2;11455:18;;;11448:30;-1:-1:-1;;;11494:18:1;;;11487:51;11555:18;;62190:103:0;11408:171:1;62190:103:0;62322:10;62306:27;;;;:15;:27;;;;;:45;;;;;;:27;:45;;;;;:::i;:::-;;;;-1:-1:-1;62364:37:0;;-1:-1:-1;62374:10:0;62364:37;;;:9;:37::i;14256:201::-;13236:13;:11;:13::i;:::-;-1:-1:-1;;;;;14345:22:0;::::1;14337:73;;;::::0;-1:-1:-1;;;14337:73:0;;11029:2:1;14337:73:0::1;::::0;::::1;11011:21:1::0;11068:2;11048:18;;;11041:30;11107:34;11087:18;;;11080:62;-1:-1:-1;;;11158:18:1;;;11151:36;11204:19;;14337:73:0::1;11001:228:1::0;14337:73:0::1;14421:28;14440:8;14421:18;:28::i;39287:273::-:0;39344:4;39400:7;66315:1;39381:26;;:66;;;;;39434:13;;39424:7;:23;39381:66;:152;;;;-1:-1:-1;;39485:26:0;;;;:17;:26;;;;;;-1:-1:-1;;;39485:43:0;:48;;39287:273::o;13515:132::-;13423:6;;-1:-1:-1;;;;;13423:6:0;57935:10;13579:23;13571:68;;;;-1:-1:-1;;;13571:68:0;;12901:2:1;13571:68:0;;;12883:21:1;;;12920:18;;;12913:30;12979:34;12959:18;;;12952:62;13031:18;;13571:68:0;12873:182:1;32247:1129:0;32314:7;32349;;66315:1;32398:23;32394:915;;32451:13;;32444:4;:20;32440:869;;;32489:14;32506:23;;;:17;:23;;;;;;-1:-1:-1;;;32595:23:0;;32591:699;;33114:113;33121:11;33114:113;;-1:-1:-1;;;33192:6:0;33174:25;;;;:17;:25;;;;;;33114:113;;32591:699;32440:869;;33337:31;;-1:-1:-1;;;33337:31:0;;;;;;;;;;;49948:3063;50028:27;50058;50077:7;50058:18;:27::i;:::-;50028:57;-1:-1:-1;50028:57:0;50098:12;;50220:28;50240:7;45183:27;45482:21;;;45309:15;45524:4;45517:36;45606:4;45590:21;;45696:26;;45590:21;;45433:300;50220:28;50163:85;;;;50265:13;50261:310;;;50386:62;50405:15;50422:4;57935:10;50428:19;57848:105;50386:62;50381:178;;50472:43;50489:4;57935:10;38142:164;:::i;50472:43::-;50467:92;;50524:35;;-1:-1:-1;;;50524:35:0;;;;;;;;;;;50467:92;50727:15;50724:2;;;50867:1;50846:19;50839:30;50724:2;-1:-1:-1;;;;;51485:24:0;;;;;;:18;:24;;;;;:59;;51513:31;51485:59;;;35229:11;35205:22;35201:40;35188:62;-1:-1:-1;;;35188:62:0;51782:26;;;;:17;:26;;;;;:203;-1:-1:-1;;;52105:46:0;;52101:626;;52209:1;52199:11;;52177:19;52332:30;;;:17;:30;;;;;;52328:384;;52470:13;;52455:11;:28;52451:242;;52617:30;;;;:17;:30;;;;;:52;;;52451:242;52101:626;;52755:35;;52782:7;;52778:1;;-1:-1:-1;;;;;52755:35:0;;;;;52778:1;;52755:35;-1:-1:-1;;52978:12:0;:14;;;;;;-1:-1:-1;;;;49948:3063:0:o;14617:191::-;14710:6;;;-1:-1:-1;;;;;14727:17:0;;;-1:-1:-1;;;;;;14727:17:0;;;;;;;14760:40;;14710:6;;;14727:17;14710:6;;14760:40;;14691:16;;14760:40;14617:191;;:::o;39644:104::-;39713:27;39723:2;39727:8;39713:27;;;;;;;;;;;;:9;:27::i;53503:716::-;53687:88;;-1:-1:-1;;;53687:88:0;;53666:4;;-1:-1:-1;;;;;53687:45:0;;;;;:88;;57935:10;;53754:4;;53760:7;;53769:5;;53687:88;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53687:88:0;;;;;;;;-1:-1:-1;;53687:88:0;;;;;;;;;;;;:::i;:::-;;;53683:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53970:13:0;;53966:235;;54016:40;;-1:-1:-1;;;54016:40:0;;;;;;;;;;;53966:235;54159:6;54153:13;54144:6;54140:2;54136:15;54129:38;53683:529;-1:-1:-1;;;;;;53846:64:0;-1:-1:-1;;;53846:64:0;;-1:-1:-1;53503:716:0;;;;;;:::o;9155:723::-;9211:13;9432:10;9428:53;;-1:-1:-1;;9459:10:0;;;;;;;;;;;;-1:-1:-1;;;9459:10:0;;;;;9155:723::o;9428:53::-;9506:5;9491:12;9547:78;9554:9;;9547:78;;9580:8;;;;:::i;:::-;;-1:-1:-1;9603:10:0;;-1:-1:-1;9611:2:0;9603:10;;:::i;:::-;;;9547:78;;;9635:19;9667:6;9657:17;;;;;;-1:-1:-1;;;9657:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9657:17:0;;9635:39;;9685:154;9692:10;;9685:154;;9719:11;9729:1;9719:11;;:::i;:::-;;-1:-1:-1;9788:10:0;9796:2;9788:5;:10;:::i;:::-;9775:24;;:2;:24;:::i;:::-;9762:39;;9745:6;9752;9745:14;;;;;;-1:-1:-1;;;9745:14:0;;;;;;;;;;;;:56;-1:-1:-1;;;;;9745:56:0;;;;;;;;-1:-1:-1;9816:11:0;9825:2;9816:11;;:::i;:::-;;;9685:154;;66091:124;66151:13;66191:16;66184:23;;;;;:::i;1219:190::-;1344:4;1397;1368:25;1381:5;1388:4;1368:12;:25::i;:::-;:33;;1219:190;-1:-1:-1;;;;1219:190:0:o;40164:681::-;40287:19;40293:2;40297:8;40287:5;:19::i;:::-;-1:-1:-1;;;;;40348:14:0;;;:19;40344:483;;40388:11;40402:13;40450:14;;;40483:233;40514:62;40553:1;40557:2;40561:7;;;;;;40570:5;40514:30;:62::i;:::-;40509:167;;40612:40;;-1:-1:-1;;;40612:40:0;;;;;;;;;;;40509:167;40711:3;40703:5;:11;40483:233;;40798:3;40781:13;;:20;40777:34;;40803:8;;;40777:34;40344:483;;40164:681;;;:::o;2086:296::-;2169:7;2212:4;2169:7;2227:118;2251:5;:12;2247:1;:16;2227:118;;;2300:33;2310:12;2324:5;2330:1;2324:8;;;;;;-1:-1:-1;;;2324:8:0;;;;;;;;;;;;;;;2300:9;:33::i;:::-;2285:48;-1:-1:-1;2265:3:0;;;;:::i;:::-;;;;2227:118;;;-1:-1:-1;2362:12:0;2086:296;-1:-1:-1;;;2086:296:0:o;41118:1529::-;41183:20;41206:13;-1:-1:-1;;;;;41234:16:0;;41230:48;;41259:19;;-1:-1:-1;;;41259:19:0;;;;;;;;;;;41230:48;41293:13;41289:44;;41315:18;;-1:-1:-1;;;41315:18:0;;;;;;;;;;;41289:44;-1:-1:-1;;;;;41821:22:0;;;;;;:18;:22;;25265:2;41821:22;;:70;;41859:31;41847:44;;41821:70;;;35229:11;35205:22;35201:40;-1:-1:-1;36939:15:0;;36914:23;36910:45;35198:51;35188:62;42134:31;;;;:17;:31;;;;;:173;42152:12;42383:23;;;42421:101;42448:35;;42473:9;;;;;-1:-1:-1;;;;;42448:35:0;;;42465:1;;42448:35;;42465:1;;42448:35;42517:3;42507:7;:13;42421:101;;42538:13;:19;-1:-1:-1;38377:185:0;;;:::o;8293:149::-;8356:7;8387:1;8383;:5;:51;;8518:13;8612:15;;;8648:4;8641:15;;;8695:4;8679:21;;8383:51;;;-1:-1:-1;8518:13:0;8612:15;;;8648:4;8641:15;8695:4;8679:21;;;8293:149::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:406:1;78:5;112:18;104:6;101:30;98:2;;;134:18;;:::i;:::-;172:57;217:2;196:15;;-1:-1:-1;;192:29:1;223:4;188:40;172:57;:::i;:::-;163:66;;252:6;245:5;238:21;292:3;283:6;278:3;274:16;271:25;268:2;;;309:1;306;299:12;268:2;358:6;353:3;346:4;339:5;335:16;322:43;412:1;405:4;396:6;389:5;385:18;381:29;374:40;88:332;;;;;:::o;425:173::-;493:20;;-1:-1:-1;;;;;542:31:1;;532:42;;522:2;;588:1;585;578:12;522:2;474:124;;;:::o;603:743::-;657:5;710:3;703:4;695:6;691:17;687:27;677:2;;732:5;725;718:20;677:2;772:6;759:20;798:4;821:18;817:2;814:26;811:2;;;843:18;;:::i;:::-;889:2;886:1;882:10;912:28;936:2;932;928:11;912:28;:::i;:::-;974:15;;;1005:12;;;;1037:15;;;1071;;;1067:24;;1064:33;-1:-1:-1;1061:2:1;;;1114:5;1107;1100:20;1061:2;1140:5;1131:14;;1154:163;1168:2;1165:1;1162:9;1154:163;;;1225:17;;1213:30;;1186:1;1179:9;;;;;1263:12;;;;1295;;1154:163;;;-1:-1:-1;1335:5:1;667:679;-1:-1:-1;;;;;;;667:679:1:o;1351:160::-;1416:20;;1472:13;;1465:21;1455:32;;1445:2;;1501:1;1498;1491:12;1516:196;1575:6;1628:2;1616:9;1607:7;1603:23;1599:32;1596:2;;;1649:6;1641;1634:22;1596:2;1677:29;1696:9;1677:29;:::i;1717:270::-;1785:6;1793;1846:2;1834:9;1825:7;1821:23;1817:32;1814:2;;;1867:6;1859;1852:22;1814:2;1895:29;1914:9;1895:29;:::i;:::-;1885:39;;1943:38;1977:2;1966:9;1962:18;1943:38;:::i;:::-;1933:48;;1804:183;;;;;:::o;1992:338::-;2069:6;2077;2085;2138:2;2126:9;2117:7;2113:23;2109:32;2106:2;;;2159:6;2151;2144:22;2106:2;2187:29;2206:9;2187:29;:::i;:::-;2177:39;;2235:38;2269:2;2258:9;2254:18;2235:38;:::i;:::-;2225:48;;2320:2;2309:9;2305:18;2292:32;2282:42;;2096:234;;;;;:::o;2335:696::-;2430:6;2438;2446;2454;2507:3;2495:9;2486:7;2482:23;2478:33;2475:2;;;2529:6;2521;2514:22;2475:2;2557:29;2576:9;2557:29;:::i;:::-;2547:39;;2605:38;2639:2;2628:9;2624:18;2605:38;:::i;:::-;2595:48;;2690:2;2679:9;2675:18;2662:32;2652:42;;2745:2;2734:9;2730:18;2717:32;2772:18;2764:6;2761:30;2758:2;;;2809:6;2801;2794:22;2758:2;2837:22;;2890:4;2882:13;;2878:27;-1:-1:-1;2868:2:1;;2924:6;2916;2909:22;2868:2;2952:73;3017:7;3012:2;2999:16;2994:2;2990;2986:11;2952:73;:::i;:::-;2942:83;;;2465:566;;;;;;;:::o;3036:442::-;3129:6;3137;3190:2;3178:9;3169:7;3165:23;3161:32;3158:2;;;3211:6;3203;3196:22;3158:2;3239:29;3258:9;3239:29;:::i;:::-;3229:39;;3319:2;3308:9;3304:18;3291:32;3346:18;3338:6;3335:30;3332:2;;;3383:6;3375;3368:22;3332:2;3411:61;3464:7;3455:6;3444:9;3440:22;3411:61;:::i;:::-;3401:71;;;3148:330;;;;;:::o;3483:264::-;3548:6;3556;3609:2;3597:9;3588:7;3584:23;3580:32;3577:2;;;3630:6;3622;3615:22;3577:2;3658:29;3677:9;3658:29;:::i;:::-;3648:39;;3706:35;3737:2;3726:9;3722:18;3706:35;:::i;3752:264::-;3820:6;3828;3881:2;3869:9;3860:7;3856:23;3852:32;3849:2;;;3902:6;3894;3887:22;3849:2;3930:29;3949:9;3930:29;:::i;:::-;3920:39;4006:2;3991:18;;;;3978:32;;-1:-1:-1;;;3839:177:1:o;4021:442::-;4114:6;4122;4175:2;4163:9;4154:7;4150:23;4146:32;4143:2;;;4196:6;4188;4181:22;4143:2;4241:9;4228:23;4274:18;4266:6;4263:30;4260:2;;;4311:6;4303;4296:22;4260:2;4339:61;4392:7;4383:6;4372:9;4368:22;4339:61;:::i;:::-;4329:71;;;4419:38;4453:2;4442:9;4438:18;4419:38;:::i;4468:190::-;4524:6;4577:2;4565:9;4556:7;4552:23;4548:32;4545:2;;;4598:6;4590;4583:22;4545:2;4626:26;4642:9;4626:26;:::i;4663:190::-;4722:6;4775:2;4763:9;4754:7;4750:23;4746:32;4743:2;;;4796:6;4788;4781:22;4743:2;-1:-1:-1;4824:23:1;;4733:120;-1:-1:-1;4733:120:1:o;4858:255::-;4916:6;4969:2;4957:9;4948:7;4944:23;4940:32;4937:2;;;4990:6;4982;4975:22;4937:2;5034:9;5021:23;5053:30;5077:5;5053:30;:::i;5118:259::-;5187:6;5240:2;5228:9;5219:7;5215:23;5211:32;5208:2;;;5261:6;5253;5246:22;5208:2;5298:9;5292:16;5317:30;5341:5;5317:30;:::i;5382:480::-;5451:6;5504:2;5492:9;5483:7;5479:23;5475:32;5472:2;;;5525:6;5517;5510:22;5472:2;5570:9;5557:23;5603:18;5595:6;5592:30;5589:2;;;5640:6;5632;5625:22;5589:2;5668:22;;5721:4;5713:13;;5709:27;-1:-1:-1;5699:2:1;;5755:6;5747;5740:22;5699:2;5783:73;5848:7;5843:2;5830:16;5825:2;5821;5817:11;5783:73;:::i;6062:535::-;6153:6;6161;6214:2;6202:9;6193:7;6189:23;6185:32;6182:2;;;6235:6;6227;6220:22;6182:2;6279:9;6266:23;6329:4;6322:5;6318:16;6311:5;6308:27;6298:2;;6354:6;6346;6339:22;6602:257;6643:3;6681:5;6675:12;6708:6;6703:3;6696:19;6724:63;6780:6;6773:4;6768:3;6764:14;6757:4;6750:5;6746:16;6724:63;:::i;:::-;6841:2;6820:15;-1:-1:-1;;6816:29:1;6807:39;;;;6848:4;6803:50;;6651:208;-1:-1:-1;;6651:208:1:o;6864:185::-;6906:3;6944:5;6938:12;6959:52;7004:6;6999:3;6992:4;6985:5;6981:16;6959:52;:::i;:::-;7027:16;;;;;6914:135;-1:-1:-1;;6914:135:1:o;7406:637::-;7686:3;7724:6;7718:13;7740:53;7786:6;7781:3;7774:4;7766:6;7762:17;7740:53;:::i;:::-;7856:13;;7815:16;;;;7878:57;7856:13;7815:16;7912:4;7900:17;;7878:57;:::i;:::-;-1:-1:-1;;;7957:20:1;;7986:22;;;8035:1;8024:13;;7694:349;-1:-1:-1;;;;7694:349:1:o;8048:1305::-;8325:3;8354;8389:6;8383:13;8419:3;8441:1;8469:9;8465:2;8461:18;8451:28;;8529:2;8518:9;8514:18;8551;8541:2;;8595:4;8587:6;8583:17;8573:27;;8541:2;8621;8669;8661:6;8658:14;8638:18;8635:38;8632:2;;;-1:-1:-1;;;8696:33:1;;8752:4;8749:1;8742:15;8782:4;8703:3;8770:17;8632:2;8813:18;8840:104;;;;8958:1;8953:322;;;;8806:469;;8840:104;-1:-1:-1;;8873:24:1;;8861:37;;8918:16;;;;-1:-1:-1;8840:104:1;;8953:322;15799:4;15818:17;;;15868:4;15852:21;;9048:3;9064:165;9078:6;9075:1;9072:13;9064:165;;;9156:14;;9143:11;;;9136:35;9199:16;;;;9093:10;;9064:165;;;9068:3;;9258:6;9253:3;9249:16;9242:23;;8806:469;;;;;;;9291:56;9316:30;9342:3;9334:6;9316:30;:::i;:::-;-1:-1:-1;;;7114:20:1;;7159:1;7150:11;;7104:63;9291:56;9284:63;8333:1020;-1:-1:-1;;;;;8333:1020:1:o;9566:488::-;-1:-1:-1;;;;;9835:15:1;;;9817:34;;9887:15;;9882:2;9867:18;;9860:43;9934:2;9919:18;;9912:34;;;9982:3;9977:2;9962:18;;9955:31;;;9760:4;;10003:45;;10028:19;;10020:6;10003:45;:::i;:::-;9995:53;9769:285;-1:-1:-1;;;;;;9769:285:1:o;10251:219::-;10400:2;10389:9;10382:21;10363:4;10420:44;10460:2;10449:9;10445:18;10437:6;10420:44;:::i;13060:352::-;13262:2;13244:21;;;13301:2;13281:18;;;13274:30;13340;13335:2;13320:18;;13313:58;13403:2;13388:18;;13234:178::o;13417:398::-;13619:2;13601:21;;;13658:2;13638:18;;;13631:30;13697:34;13692:2;13677:18;;13670:62;-1:-1:-1;;;13763:2:1;13748:18;;13741:32;13805:3;13790:19;;13591:224::o;15472:275::-;15543:2;15537:9;15608:2;15589:13;;-1:-1:-1;;15585:27:1;15573:40;;15643:18;15628:34;;15664:22;;;15625:62;15622:2;;;15690:18;;:::i;:::-;15726:2;15719:22;15517:230;;-1:-1:-1;15517:230:1:o;15884:128::-;15924:3;15955:1;15951:6;15948:1;15945:13;15942:2;;;15961:18;;:::i;:::-;-1:-1:-1;15997:9:1;;15932:80::o;16017:120::-;16057:1;16083;16073:2;;16088:18;;:::i;:::-;-1:-1:-1;16122:9:1;;16063:74::o;16142:125::-;16182:4;16210:1;16207;16204:8;16201:2;;;16215:18;;:::i;:::-;-1:-1:-1;16252:9:1;;16191:76::o;16272:258::-;16344:1;16354:113;16368:6;16365:1;16362:13;16354:113;;;16444:11;;;16438:18;16425:11;;;16418:39;16390:2;16383:10;16354:113;;;16485:6;16482:1;16479:13;16476:2;;;-1:-1:-1;;16520:1:1;16502:16;;16495:27;16325:205::o;16535:380::-;16614:1;16610:12;;;;16657;;;16678:2;;16732:4;16724:6;16720:17;16710:27;;16678:2;16785;16777:6;16774:14;16754:18;16751:38;16748:2;;;16831:10;16826:3;16822:20;16819:1;16812:31;16866:4;16863:1;16856:15;16894:4;16891:1;16884:15;16748:2;;16590:325;;;:::o;16920:135::-;16959:3;-1:-1:-1;;16980:17:1;;16977:2;;;17000:18;;:::i;:::-;-1:-1:-1;17047:1:1;17036:13;;16967:88::o;17060:112::-;17092:1;17118;17108:2;;17123:18;;:::i;:::-;-1:-1:-1;17157:9:1;;17098:74::o;17177:127::-;17238:10;17233:3;17229:20;17226:1;17219:31;17269:4;17266:1;17259:15;17293:4;17290:1;17283:15;17309:127;17370:10;17365:3;17361:20;17358:1;17351:31;17401:4;17398:1;17391:15;17425:4;17422:1;17415:15;17441:127;17502:10;17497:3;17493:20;17490:1;17483:31;17533:4;17530:1;17523:15;17557:4;17554:1;17547:15;17573:131;-1:-1:-1;;;;;;17647:32:1;;17637:43;;17627:2;;17694:1;17691;17684:12

Swarm Source

ipfs://bd6a33171bdcb4ad6f86df73423af0f454c662873d2f4971c92f192cfa68bf9c

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

Tools & Services