Token

FaceX (FACEX)

ERC-20

Overview

Max Total Supply

4,000 FACEX

Holders

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 0 Decimals)

0x6937682cd53b2a4aa78c3277229f5f1c330beb82

Filtered by Token Holder

0x3877E0B7764ad5615635d439010Ce195a99b918a

Balance

0 FACEX

Value

$0.00

0x3877e0b7764ad5615635d439010ce195a99b918a

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

FaceX

Compiler Version

v0.8.13+commit.abaa5c0e

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

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

// Sources flattened with hardhat v2.9.7 https://hardhat.org

// File erc721a/contracts/[email protected]


// ERC721A Contracts v4.0.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();

    /**
     * The caller cannot approve to the current owner.
     */
    error ApprovalToCurrentOwner();

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

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

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


// File erc721a/contracts/[email protected]


// ERC721A Contracts v4.0.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 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`
    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 auxillary 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 auxillary 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;
        assembly { // Cast aux without masking.
            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;
    }

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

    /**
     * @dev Casts the address to uint256 without masking.
     */
    function _addressToUint256(address value) private pure returns (uint256 result) {
        assembly {
            result := value
        }
    }

    /**
     * @dev Casts the boolean to uint256 without branching.
     */
    function _boolToUint256(bool value) private pure returns (uint256 result) {
        assembly {
            result := value
        }
    }

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

        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-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        _transfer(from, to, tokenId);
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (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.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

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

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the balance and number minted.
            _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] =
                _addressToUint256(to) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                (_boolToUint256(quantity == 1) << BITPOS_NEXT_INITIALIZED);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            if (to.code.length != 0) {
                do {
                    emit Transfer(address(0), to, updatedIndex);
                    if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (updatedIndex < end);
                // Reentrancy protection
                if (_currentIndex != startTokenId) revert();
            } else {
                do {
                    emit Transfer(address(0), to, updatedIndex++);
                } while (updatedIndex < end);
            }
            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

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

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

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the balance and number minted.
            _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] =
                _addressToUint256(to) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                (_boolToUint256(quantity == 1) << BITPOS_NEXT_INITIALIZED);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            do {
                emit Transfer(address(0), to, updatedIndex++);
            } while (updatedIndex < end);

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

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) private {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

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

        bool isApprovedOrOwner = (_msgSenderERC721A() == from ||
            isApprovedForAll(from, _msgSenderERC721A()) ||
            getApproved(tokenId) == _msgSenderERC721A());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

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

        // 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] =
                _addressToUint256(to) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                BITMASK_NEXT_INITIALIZED;

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

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSenderERC721A() == from ||
                isApprovedForAll(from, _msgSenderERC721A()) ||
                getApproved(tokenId) == _msgSenderERC721A());

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

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

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

        // 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] =
                _addressToUint256(from) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                BITMASK_BURNED | 
                BITMASK_NEXT_INITIALIZED;

            // 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 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 @openzeppelin/contracts/utils/[email protected]


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

pragma solidity ^0.8.0;

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

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

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

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

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


// File @openzeppelin/contracts/utils/cryptography/[email protected]


// OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}


// File @openzeppelin/contracts/utils/introspection/[email protected]


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

pragma solidity ^0.8.0;

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


// File @openzeppelin/contracts/token/ERC721/[email protected]


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must 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);
}


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]


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

pragma solidity ^0.8.0;

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

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

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


// File @openzeppelin/contracts/utils/[email protected]


// 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/security/[email protected]


// OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}


// File @openzeppelin/contracts/access/[email protected]


// OpenZeppelin Contracts v4.4.1 (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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

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

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

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


// File @openzeppelin/contracts/access/[email protected]


// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}


// File @openzeppelin/contracts/access/[email protected]


// OpenZeppelin Contracts v4.4.1 (access/IAccessControlEnumerable.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
 */
interface IAccessControlEnumerable is IAccessControl {
    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) external view returns (address);

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) external view returns (uint256);
}


// File @openzeppelin/contracts/utils/introspection/[email protected]


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

pragma solidity ^0.8.0;

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


// File @openzeppelin/contracts/access/[email protected]


// OpenZeppelin Contracts (last updated v4.6.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;




/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

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

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
     * Overriding this function changes the behavior of the {onlyRole} modifier.
     *
     * Format of the revert message is described in {_checkRole}.
     *
     * _Available since v4.6._
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(uint160(account), 20),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}


// File @openzeppelin/contracts/utils/structs/[email protected]


// OpenZeppelin Contracts (last updated v4.6.0) (utils/structs/EnumerableSet.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}


// File @openzeppelin/contracts/access/[email protected]


// OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControlEnumerable.sol)

pragma solidity ^0.8.0;



/**
 * @dev Extension of {AccessControl} that allows enumerating the members of each role.
 */
abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl {
    using EnumerableSet for EnumerableSet.AddressSet;

    mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers;

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

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) public view virtual override returns (address) {
        return _roleMembers[role].at(index);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view virtual override returns (uint256) {
        return _roleMembers[role].length();
    }

    /**
     * @dev Overload {_grantRole} to track enumerable memberships
     */
    function _grantRole(bytes32 role, address account) internal virtual override {
        super._grantRole(role, account);
        _roleMembers[role].add(account);
    }

    /**
     * @dev Overload {_revokeRole} to track enumerable memberships
     */
    function _revokeRole(bytes32 role, address account) internal virtual override {
        super._revokeRole(role, account);
        _roleMembers[role].remove(account);
    }
}


// File contracts/IFaceX.sol

pragma solidity 0.8.13;

interface IFaceX {

    function mintTo(address _to, uint256 _quantity) external;

}


// File contracts/FaceX.sol

//SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.13;







contract FaceX is ERC721A, Ownable, AccessControlEnumerable, Pausable, IFaceX {
    using Strings for uint256;
    using ECDSA for bytes32;

    uint256 public constant MAX_SUPPLY = 4000;

    //Genral admin role, grants minter role to sale contract.
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
    //Minter role, allowed to perform mints on this contract.
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");

    //Base uri for metadatas, used only after reveal
    string public baseURI;

    //uri for metadatas pre-reveal
    string public notRevealedUri;

    //Indicates if NFTs have been revealed
    bool public revealed = false;

    constructor() ERC721A("FaceX", "FACEX") {
        _setRoleAdmin(MINTER_ROLE, ADMIN_ROLE); //Admin role manages minter role

        _grantRole(ADMIN_ROLE, msg.sender); //Initial admin is deployer

        _safeMint(msg.sender, 1); // To configure OpenSea
    }

    //Restrict function access to admin only
    modifier onlyAdmin() {
        require(
            hasRole(ADMIN_ROLE, msg.sender),
            "You are not allowed to perform this action."
        );
        _;
    }

    //Restrict function access to minter only
    modifier onlyMinter() {
        require(
            hasRole(MINTER_ROLE, msg.sender),
            "You are not allowed to perform this action."
        );
        _;
    }

    //Allows ADMIN_ROLE to be transfered
    function transferAdmin(address _to) external onlyAdmin {
        require(_to != address(0), "Can't put 0 address");

        _revokeRole(ADMIN_ROLE, msg.sender);
        _grantRole(ADMIN_ROLE, _to);
    }

    /**
     * @dev Use this function with an address that has been granted the minter role to mint tokens
     * @param _to the address that the tokens will be minted to
     * @param _quantity Quantity to mint
     */
    function mintTo(address _to, uint256 _quantity) external onlyMinter {
        require(totalSupply() + _quantity <= MAX_SUPPLY, "Max Supply Reached");

        _safeMint(_to, _quantity);
    }

    //Reveal the NFTs. Calling the function multiple time does not affect the metadatas
    function reveal() public onlyAdmin {
        revealed = true;
    }

    //Change the uri for pre-reveal
    function setNotRevealedURI(string memory _notRevealedURI) public onlyAdmin {
        notRevealedUri = _notRevealedURI;
    }

    //Change the uri post reveal
    function setBaseURI(string memory _newBaseURI) public onlyAdmin {
        baseURI = _newBaseURI;
    }

    /**
     * @dev This function override the base tokenURI function to manage the revealed state.
     * @dev When the NFTs are not revealed they all have the same URI. When they are revealed the URI is formed as : `baseURI/tokenId`
     *
     */
    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721A)
        returns (string memory)
    {
        if (revealed == false) {
            return notRevealedUri;
        }

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

    /**
     * @dev Indicates that this contract supports both ERC721Metadata and AccessControlEnumerable interfaces
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(AccessControlEnumerable, ERC721A)
        returns (bool)
    {
        if (interfaceId == type(IAccessControlEnumerable).interfaceId) {
            return true;
        }
        if (interfaceId == type(IERC721Metadata).interfaceId) {
            return true;
        }
        return super.supportsInterface(interfaceId);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","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":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_quantity","type":"uint256"}],"name":"mintTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"notRevealedUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_notRevealedURI","type":"string"}],"name":"setNotRevealedURI","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":"_to","type":"address"}],"name":"transferAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

91088:3887:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94522:450;;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;94522:450:0;;;;;;;;18162:100;;;:::i;:::-;;;;;;;:::i;20230:204::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1692:32:1;;;1674:51;;1662:2;1647:18;20230:204:0;1528:203:1;91671:28:0;;;:::i;19690:474::-;;;;;;:::i;:::-;;:::i;:::-;;12203:315;12469:12;;12256:7;12453:13;:28;12203:315;;;2319:25:1;;;2307:2;2292:18;12203:315:0;2173:177:1;21116:170:0;;;;;;:::i;:::-;;:::i;72262:131::-;;;;;;:::i;:::-;72336:7;72363:12;;;:6;:12;;;;;:22;;;;72262:131;72655:147;;;;;;:::i;:::-;;:::i;91237:41::-;;91274:4;91237:41;;73703:218;;;;;;:::i;:::-;;:::i;21357:185::-;;;;;;:::i;:::-;;:::i;93010:195::-;;;;;;:::i;:::-;;:::i;91752:28::-;;;;;;;;;93584:104;;;;;;:::i;:::-;;:::i;58761:86::-;58832:7;;;;58761:86;;17951:144;;;;;;:::i;:::-;;:::i;91605:21::-;;;:::i;13828:224::-;;;;;;:::i;:::-;;:::i;61666:103::-;;;:::i;92568:209::-;;;;;;:::i;:::-;;:::i;91350:60::-;;-1:-1:-1;;;;;;;;;;;91350:60:0;;61015:87;61088:6;;-1:-1:-1;;;;;61088:6:0;61015:87;;89818:153;;;;;;:::i;:::-;;:::i;70722:147::-;;;;;;:::i;:::-;;:::i;18331:104::-;;;:::i;69827:49::-;;69872:4;69827:49;;20506:308;;;;;;:::i;:::-;;:::i;93302:69::-;;;:::i;21613:396::-;;;;;;:::i;:::-;;:::i;93951:435::-;;;;;;:::i;:::-;;:::i;90145:142::-;;;;;;:::i;:::-;;:::i;91480:62::-;;91518:24;91480:62;;73047:149;;;;;;:::i;:::-;;:::i;20885:164::-;;;;;;:::i;:::-;-1:-1:-1;;;;;21006:25:0;;;20982:4;21006:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;20885:164;93416:126;;;;;;:::i;:::-;;:::i;61924:201::-;;;;;;:::i;:::-;;:::i;94522:450::-;94686:4;-1:-1:-1;;;;;;;;;94712:57:0;;;94708:101;;-1:-1:-1;94793:4:0;;94522:450;-1:-1:-1;94522:450:0:o;94708:101::-;-1:-1:-1;;;;;;;;;94823:48:0;;;94819:92;;-1:-1:-1;94895:4:0;;94522:450;-1:-1:-1;94522:450:0:o;94819:92::-;94928:36;94952:11;94928:23;:36::i;:::-;94921:43;94522:450;-1:-1:-1;;94522:450:0:o;18162:100::-;18216:13;18249:5;18242:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18162:100;:::o;20230:204::-;20298:7;20323:16;20331:7;20323;:16::i;:::-;20318:64;;20348:34;;-1:-1:-1;;;20348:34:0;;;;;;;;;;;20318:64;-1:-1:-1;20402:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;20402:24:0;;20230:204::o;91671:28::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;19690:474::-;19763:13;19795:27;19814:7;19795:18;:27::i;:::-;19763:61;;19845:5;-1:-1:-1;;;;;19839:11:0;:2;-1:-1:-1;;;;;19839:11:0;;19835:48;;19859:24;;-1:-1:-1;;;19859:24:0;;;;;;;;;;;19835:48;36333:10;-1:-1:-1;;;;;19900:28:0;;;19896:175;;19948:44;19965:5;36333:10;20885:164;:::i;19948:44::-;19943:128;;20020:35;;-1:-1:-1;;;20020:35:0;;;;;;;;;;;19943:128;20083:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;20083:29:0;-1:-1:-1;;;;;20083:29:0;;;;;;;;;20128:28;;20083:24;;20128:28;;;;;;;19752:412;19690:474;;:::o;21116:170::-;21250:28;21260:4;21266:2;21270:7;21250:9;:28::i;:::-;21116:170;;;:::o;72655:147::-;72336:7;72363:12;;;:6;:12;;;;;:22;;;70318:16;70329:4;70318:10;:16::i;:::-;72769:25:::1;72780:4;72786:7;72769:10;:25::i;73703:218::-:0;-1:-1:-1;;;;;73799:23:0;;36333:10;73799:23;73791:83;;;;-1:-1:-1;;;73791:83:0;;6859:2:1;73791:83:0;;;6841:21:1;6898:2;6878:18;;;6871:30;6937:34;6917:18;;;6910:62;-1:-1:-1;;;6988:18:1;;;6981:45;7043:19;;73791:83:0;;;;;;;;;73887:26;73899:4;73905:7;73887:11;:26::i;:::-;73703:218;;:::o;21357:185::-;21495:39;21512:4;21518:2;21522:7;21495:39;;;;;;;;;;;;:16;:39::i;93010:195::-;92395:32;91518:24;92416:10;92395:7;:32::i;:::-;92373:125;;;;-1:-1:-1;;;92373:125:0;;;;;;;:::i;:::-;91274:4:::1;93113:9;93097:13;12469:12:::0;;12256:7;12453:13;:28;;12203:315;93097:13:::1;:25;;;;:::i;:::-;:39;;93089:70;;;::::0;-1:-1:-1;;;93089:70:0;;7952:2:1;93089:70:0::1;::::0;::::1;7934:21:1::0;7991:2;7971:18;;;7964:30;-1:-1:-1;;;8010:18:1;;;8003:48;8068:18;;93089:70:0::1;7750:342:1::0;93089:70:0::1;93172:25;93182:3;93187:9;93172;:25::i;93584:104::-:0;92163:31;-1:-1:-1;;;;;;;;;;;92183:10:0;92163:7;:31::i;:::-;92141:124;;;;-1:-1:-1;;;92141:124:0;;;;;;;:::i;:::-;93659:21;;::::1;::::0;:7:::1;::::0;:21:::1;::::0;::::1;::::0;::::1;:::i;17951:144::-:0;18015:7;18058:27;18077:7;18058:18;:27::i;91605:21::-;;;;;;;:::i;13828:224::-;13892:7;-1:-1:-1;;;;;13916:19:0;;13912:60;;13944:28;;-1:-1:-1;;;13944:28:0;;;;;;;;;;;13912:60;-1:-1:-1;;;;;;13990:25:0;;;;;:18;:25;;;;;;9167:13;13990:54;;13828:224::o;61666:103::-;61088:6;;-1:-1:-1;;;;;61088:6:0;36333:10;61235:23;61227:68;;;;-1:-1:-1;;;61227:68:0;;8299:2:1;61227:68:0;;;8281:21:1;;;8318:18;;;8311:30;8377:34;8357:18;;;8350:62;8429:18;;61227:68:0;8097:356:1;61227:68:0;61731:30:::1;61758:1;61731:18;:30::i;:::-;61666:103::o:0;92568:209::-;92163:31;-1:-1:-1;;;;;;;;;;;92183:10:0;92163:7;:31::i;:::-;92141:124;;;;-1:-1:-1;;;92141:124:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;92642:17:0;::::1;92634:49;;;::::0;-1:-1:-1;;;92634:49:0;;8660:2:1;92634:49:0::1;::::0;::::1;8642:21:1::0;8699:2;8679:18;;;8672:30;-1:-1:-1;;;8718:18:1;;;8711:49;8777:18;;92634:49:0::1;8458:343:1::0;92634:49:0::1;92696:35;-1:-1:-1::0;;;;;;;;;;;92720:10:0::1;92696:11;:35::i;:::-;92742:27;-1:-1:-1::0;;;;;;;;;;;92765:3:0::1;92742:10;:27::i;:::-;92568:209:::0;:::o;89818:153::-;89908:7;89935:18;;;:12;:18;;;;;:28;;89957:5;89935:21;:28::i;:::-;89928:35;89818:153;-1:-1:-1;;;89818:153:0:o;70722:147::-;70808:4;70832:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;70832:29:0;;;;;;;;;;;;;;;70722:147::o;18331:104::-;18387:13;18420:7;18413:14;;;;;:::i;20506:308::-;36333:10;-1:-1:-1;;;;;20605:31:0;;;20601:61;;20645:17;;-1:-1:-1;;;20645:17:0;;;;;;;;;;;20601:61;36333:10;20675:39;;;;:18;:39;;;;;;;;-1:-1:-1;;;;;20675:49:0;;;;;;;;;;;;:60;;-1:-1:-1;;20675:60:0;;;;;;;;;;20751:55;;540:41:1;;;20675:49:0;;36333:10;20751:55;;513:18:1;20751:55:0;;;;;;;20506:308;;:::o;93302:69::-;92163:31;-1:-1:-1;;;;;;;;;;;92183:10:0;92163:7;:31::i;:::-;92141:124;;;;-1:-1:-1;;;92141:124:0;;;;;;;:::i;:::-;93348:8:::1;:15:::0;;-1:-1:-1;;93348:15:0::1;93359:4;93348:15;::::0;;93302:69::o;21613:396::-;21780:28;21790:4;21796:2;21800:7;21780:9;:28::i;:::-;-1:-1:-1;;;;;21823:14:0;;;:19;21819:183;;21862:56;21893:4;21899:2;21903:7;21912:5;21862:30;:56::i;:::-;21857:145;;21946:40;;-1:-1:-1;;;21946:40:0;;;;;;;;;;;21857:145;21613:396;;;;:::o;93951:435::-;94096:8;;94061:13;;94096:8;;:17;;:8;:17;94092:71;;94137:14;94130:21;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;93951:435;;;:::o;94092:71::-;94175:28;94206:7;94175:38;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94275:1;94250:14;94244:28;:32;:134;;;;;;;;;;;;;;;;;94320:14;94336:18;:7;:16;:18::i;:::-;94303:52;;;;;;;;;:::i;:::-;;;;;;;;;;;;;94224:154;93951:435;-1:-1:-1;;;93951:435:0:o;90145:142::-;90225:7;90252:18;;;:12;:18;;;;;:27;;:25;:27::i;73047:149::-;72336:7;72363:12;;;:6;:12;;;;;:22;;;70318:16;70329:4;70318:10;:16::i;:::-;73162:26:::1;73174:4;73180:7;73162:11;:26::i;93416:126::-:0;92163:31;-1:-1:-1;;;;;;;;;;;92183:10:0;92163:7;:31::i;:::-;92141:124;;;;-1:-1:-1;;;92141:124:0;;;;;;;:::i;:::-;93502:32;;::::1;::::0;:14:::1;::::0;:32:::1;::::0;::::1;::::0;::::1;:::i;61924:201::-:0;61088:6;;-1:-1:-1;;;;;61088:6:0;36333:10;61235:23;61227:68;;;;-1:-1:-1;;;61227:68:0;;8299:2:1;61227:68:0;;;8281:21:1;;;8318:18;;;8311:30;8377:34;8357:18;;;8350:62;8429:18;;61227:68:0;8097:356:1;61227:68:0;-1:-1:-1;;;;;62013:22:0;::::1;62005:73;;;::::0;-1:-1:-1;;;62005:73:0;;9483:2:1;62005:73:0::1;::::0;::::1;9465:21:1::0;9522:2;9502:18;;;9495:30;9561:34;9541:18;;;9534:62;-1:-1:-1;;;9612:18:1;;;9605:36;9658:19;;62005:73:0::1;9281:402:1::0;62005:73:0::1;62089:28;62108:8;62089:18;:28::i;75204:238::-:0;75288:22;75296:4;75302:7;75288;:22::i;:::-;75283:152;;75327:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;75327:29:0;;;;;;;;;:36;;-1:-1:-1;;75327:36:0;75359:4;75327:36;;;75410:12;36333:10;;36246:105;75410:12;-1:-1:-1;;;;;75383:40:0;75401:7;-1:-1:-1;;;;;75383:40:0;75395:4;75383:40;;;;;;;;;;75204:238;;:::o;83715:152::-;83785:4;83809:50;83814:3;-1:-1:-1;;;;;83834:23:0;;83809:4;:50::i;89005:214::-;89090:4;-1:-1:-1;;;;;;89114:57:0;;-1:-1:-1;;;89114:57:0;;:97;;;89175:36;89199:11;89175:23;:36::i;22264:273::-;22321:4;22411:13;;22401:7;:23;22358:152;;;;-1:-1:-1;;22462:26:0;;;;:17;:26;;;;;;-1:-1:-1;;;22462:43:0;:48;;22264:273::o;15466:1129::-;15533:7;15568;15670:13;;15663:4;:20;15659:869;;;15708:14;15725:23;;;:17;:23;;;;;;;-1:-1:-1;;;15814:23:0;;:28;;15810:699;;16333:113;16340:6;16350:1;16340:11;16333:113;;-1:-1:-1;;;16411:6:0;16393:25;;;;:17;:25;;;;;;16333:113;;15810:699;15685:843;15659:869;16556:31;;-1:-1:-1;;;16556:31:0;;;;;;;;;;;27503:2515;27618:27;27648;27667:7;27648:18;:27::i;:::-;27618:57;;27733:4;-1:-1:-1;;;;;27692:45:0;27708:19;-1:-1:-1;;;;;27692:45:0;;27688:86;;27746:28;;-1:-1:-1;;;27746:28:0;;;;;;;;;;;27688:86;27787:22;36333:10;-1:-1:-1;;;;;27813:27:0;;;;:87;;-1:-1:-1;27857:43:0;27874:4;36333:10;20885:164;:::i;27857:43::-;27813:147;;;-1:-1:-1;36333:10:0;27917:20;27929:7;27917:11;:20::i;:::-;-1:-1:-1;;;;;27917:43:0;;27813:147;27787:174;;27979:17;27974:66;;28005:35;;-1:-1:-1;;;28005:35:0;;;;;;;;;;;27974:66;-1:-1:-1;;;;;28055:16:0;;28051:52;;28080:23;;-1:-1:-1;;;28080:23:0;;;;;;;;;;;28051:52;28232:24;;;;:15;:24;;;;;;;;28225:31;;-1:-1:-1;;;;;;28225:31:0;;;-1:-1:-1;;;;;28624:24:0;;;;;:18;:24;;;;;28622:26;;-1:-1:-1;;28622:26:0;;;28693:22;;;;;;;28691:24;;-1:-1:-1;28691:24:0;;;28986:26;;;:17;:26;;;;;-1:-1:-1;;;29074:15:0;9821:3;29074:41;29032:84;;:128;;28986:174;;;29280:46;;:51;;29276:626;;29384:1;29374:11;;29352:19;29507:30;;;:17;:30;;;;;;:35;;29503:384;;29645:13;;29630:11;:28;29626:242;;29792:30;;;;:17;:30;;;;;:52;;;29626:242;29333:569;29276:626;29949:7;29945:2;-1:-1:-1;;;;;29930:27:0;29939:4;-1:-1:-1;;;;;29930:27:0;;;;;;;;;;;27607:2411;;27503:2515;;;:::o;71173:105::-;71240:30;71251:4;36333:10;71240;:30::i;90380:169::-;90468:31;90485:4;90491:7;90468:16;:31::i;:::-;90510:18;;;;:12;:18;;;;;:31;;90533:7;90510:22;:31::i;90643:174::-;90732:32;90750:4;90756:7;90732:17;:32::i;:::-;90775:18;;;;:12;:18;;;;;:34;;90801:7;90775:25;:34::i;22621:104::-;22690:27;22700:2;22704:8;22690:27;;;;;;;;;;;;:9;:27::i;62285:191::-;62378:6;;;-1:-1:-1;;;;;62395:17:0;;;-1:-1:-1;;;;;;62395:17:0;;;;;;;62428:40;;62378:6;;;62395:17;62378:6;;62428:40;;62359:16;;62428:40;62348:128;62285:191;:::o;85011:158::-;85085:7;85136:22;85140:3;85152:5;85136:3;:22::i;33715:716::-;33899:88;;-1:-1:-1;;;33899:88:0;;33878:4;;-1:-1:-1;;;;;33899:45:0;;;;;:88;;36333:10;;33966:4;;33972:7;;33981:5;;33899:88;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;33899:88:0;;;;;;;;-1:-1:-1;;33899:88:0;;;;;;;;;;;;:::i;:::-;;;33895:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34182:6;:13;34199:1;34182:18;34178:235;;34228:40;;-1:-1:-1;;;34228:40:0;;;;;;;;;;;34178:235;34371:6;34365:13;34356:6;34352:2;34348:15;34341:38;33895:529;-1:-1:-1;;;;;;34058:64:0;-1:-1:-1;;;34058:64:0;;-1:-1:-1;33895:529:0;33715:716;;;;;;:::o;38796:723::-;38852:13;39073:5;39082:1;39073:10;39069:53;;-1:-1:-1;;39100:10:0;;;;;;;;;;;;-1:-1:-1;;;39100:10:0;;;;;38796:723::o;39069:53::-;39147:5;39132:12;39188:78;39195:9;;39188:78;;39221:8;;;;:::i;:::-;;-1:-1:-1;39244:10:0;;-1:-1:-1;39252:2:0;39244:10;;:::i;:::-;;;39188:78;;;39276:19;39308:6;39298:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;39298:17:0;;39276:39;;39326:154;39333:10;;39326:154;;39360:11;39370:1;39360:11;;:::i;:::-;;-1:-1:-1;39429:10:0;39437:2;39429:5;:10;:::i;:::-;39416:24;;:2;:24;:::i;:::-;39403:39;;39386:6;39393;39386:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;39386:56:0;;;;;;;;-1:-1:-1;39457:11:0;39466:2;39457:11;;:::i;:::-;;;39326:154;;84540:117;84603:7;84630:19;84638:3;80024:18;;79941:109;77630:414;77693:4;79823:19;;;:12;;;:19;;;;;;77710:327;;-1:-1:-1;77753:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;77936:18;;77914:19;;;:12;;;:19;;;;;;:40;;;;77969:11;;77710:327;-1:-1:-1;78020:5:0;78013:12;;70426:204;70511:4;-1:-1:-1;;;;;;70535:47:0;;-1:-1:-1;;;70535:47:0;;:87;;-1:-1:-1;;;;;;;;;;67788:40:0;;;70586:36;67679:157;71568:505;71657:22;71665:4;71671:7;71657;:22::i;:::-;71652:414;;71845:41;71873:7;-1:-1:-1;;;;;71845:41:0;71883:2;71845:19;:41::i;:::-;71959:38;71987:4;71994:2;71959:19;:38::i;:::-;71750:270;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;71750:270:0;;;;;;;;;;-1:-1:-1;;;71696:358:0;;;;;;;:::i;75574:239::-;75658:22;75666:4;75672:7;75658;:22::i;:::-;75654:152;;;75729:5;75697:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;75697:29:0;;;;;;;;;;:37;;-1:-1:-1;;75697:37:0;;;75754:40;36333:10;;75697:12;;75754:40;;75729:5;75754:40;75574:239;;:::o;84043:158::-;84116:4;84140:53;84148:3;-1:-1:-1;;;;;84168:23:0;;84140:7;:53::i;23098:2236::-;23221:20;23244:13;-1:-1:-1;;;;;23272:16:0;;23268:48;;23297:19;;-1:-1:-1;;;23297:19:0;;;;;;;;;;;23268:48;23331:8;23343:1;23331:13;23327:44;;23353:18;;-1:-1:-1;;;23353:18:0;;;;;;;;;;;23327:44;-1:-1:-1;;;;;23920:22:0;;;;;;:18;:22;;;;9304:2;23920:22;;;:70;;23958:31;23946:44;;23920:70;;;24233:31;;;:17;:31;;;;;24326:15;9821:3;24326:41;24284:84;;-1:-1:-1;24404:13:0;;10084:3;24389:56;24284:162;24233:213;;:31;;24527:23;;;;24571:14;:19;24567:635;;24611:313;24642:38;;24667:12;;-1:-1:-1;;;;;24642:38:0;;;24659:1;;24642:38;;24659:1;;24642:38;24708:69;24747:1;24751:2;24755:14;;;;;;24771:5;24708:30;:69::i;:::-;24703:174;;24813:40;;-1:-1:-1;;;24813:40:0;;;;;;;;;;;24703:174;24919:3;24904:12;:18;24611:313;;25005:12;24988:13;;:29;24984:43;;25019:8;;;24984:43;24567:635;;;25068:119;25099:40;;25124:14;;;;;-1:-1:-1;;;;;25099:40:0;;;25116:1;;25099:40;;25116:1;;25099:40;25182:3;25167:12;:18;25068:119;;24567:635;-1:-1:-1;25216:13:0;:28;;;25266:60;;25299:2;25303:12;25317:8;25266:60;:::i;80404:120::-;80471:7;80498:3;:11;;80510:5;80498:18;;;;;;;;:::i;:::-;;;;;;;;;80491:25;;80404:120;;;;:::o;40097:451::-;40172:13;40198:19;40230:10;40234:6;40230:1;:10;:::i;:::-;:14;;40243:1;40230:14;:::i;:::-;40220:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40220:25:0;;40198:47;;-1:-1:-1;;;40256:6:0;40263:1;40256:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;40256:15:0;;;;;;;;;-1:-1:-1;;;40282:6:0;40289:1;40282:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;40282:15:0;;;;;;;;-1:-1:-1;40313:9:0;40325:10;40329:6;40325:1;:10;:::i;:::-;:14;;40338:1;40325:14;:::i;:::-;40313:26;;40308:135;40345:1;40341;:5;40308:135;;;-1:-1:-1;;;40393:5:0;40401:3;40393:11;40380:25;;;;;;;:::i;:::-;;;;40368:6;40375:1;40368:9;;;;;;;;:::i;:::-;;;;:37;-1:-1:-1;;;;;40368:37:0;;;;;;;;-1:-1:-1;40430:1:0;40420:11;;;;;40348:3;;;:::i;:::-;;;40308:135;;;-1:-1:-1;40461:10:0;;40453:55;;;;-1:-1:-1;;;40453:55:0;;12519:2:1;40453:55:0;;;12501:21:1;;;12538:18;;;12531:30;12597:34;12577:18;;;12570:62;12649:18;;40453:55:0;12317:356:1;78220:1420:0;78286:4;78425:19;;;:12;;;:19;;;;;;78461:15;;78457:1176;;78836:21;78860:14;78873:1;78860:10;:14;:::i;:::-;78909:18;;78836:38;;-1:-1:-1;78889:17:0;;78909:22;;78930:1;;78909:22;:::i;:::-;78889:42;;78965:13;78952:9;:26;78948:405;;78999:17;79019:3;:11;;79031:9;79019:22;;;;;;;;:::i;:::-;;;;;;;;;78999:42;;79173:9;79144:3;:11;;79156:13;79144:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;79258:23;;;:12;;;:23;;;;;:36;;;78948:405;79434:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;79529:3;:12;;:19;79542:5;79529:19;;;;;;;;;;;79522:26;;;79572:4;79565:11;;;;;;;78457:1176;79616:5;79609:12;;;;;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:258::-;664:1;674:113;688:6;685:1;682:13;674:113;;;764:11;;;758:18;745:11;;;738:39;710:2;703:10;674:113;;;805:6;802:1;799:13;796:48;;;-1:-1:-1;;840:1:1;822:16;;815:27;592:258::o;855:::-;897:3;935:5;929:12;962:6;957:3;950:19;978:63;1034:6;1027:4;1022:3;1018:14;1011:4;1004:5;1000:16;978:63;:::i;:::-;1095:2;1074:15;-1:-1:-1;;1070:29:1;1061:39;;;;1102:4;1057:50;;855:258;-1:-1:-1;;855:258:1:o;1118:220::-;1267:2;1256:9;1249:21;1230:4;1287:45;1328:2;1317:9;1313:18;1305:6;1287:45;:::i;1343:180::-;1402:6;1455:2;1443:9;1434:7;1430:23;1426:32;1423:52;;;1471:1;1468;1461:12;1423:52;-1:-1:-1;1494:23:1;;1343:180;-1:-1:-1;1343:180:1:o;1736:173::-;1804:20;;-1:-1:-1;;;;;1853:31:1;;1843:42;;1833:70;;1899:1;1896;1889:12;1833:70;1736:173;;;:::o;1914:254::-;1982:6;1990;2043:2;2031:9;2022:7;2018:23;2014:32;2011:52;;;2059:1;2056;2049:12;2011:52;2082:29;2101:9;2082:29;:::i;:::-;2072:39;2158:2;2143:18;;;;2130:32;;-1:-1:-1;;;1914:254:1:o;2355:328::-;2432:6;2440;2448;2501:2;2489:9;2480:7;2476:23;2472:32;2469:52;;;2517:1;2514;2507:12;2469:52;2540:29;2559:9;2540:29;:::i;:::-;2530:39;;2588:38;2622:2;2611:9;2607:18;2588:38;:::i;:::-;2578:48;;2673:2;2662:9;2658:18;2645:32;2635:42;;2355:328;;;;;:::o;3055:254::-;3123:6;3131;3184:2;3172:9;3163:7;3159:23;3155:32;3152:52;;;3200:1;3197;3190:12;3152:52;3236:9;3223:23;3213:33;;3265:38;3299:2;3288:9;3284:18;3265:38;:::i;:::-;3255:48;;3055:254;;;;;:::o;3314:127::-;3375:10;3370:3;3366:20;3363:1;3356:31;3406:4;3403:1;3396:15;3430:4;3427:1;3420:15;3446:632;3511:5;3541:18;3582:2;3574:6;3571:14;3568:40;;;3588:18;;:::i;:::-;3663:2;3657:9;3631:2;3717:15;;-1:-1:-1;;3713:24:1;;;3739:2;3709:33;3705:42;3693:55;;;3763:18;;;3783:22;;;3760:46;3757:72;;;3809:18;;:::i;:::-;3849:10;3845:2;3838:22;3878:6;3869:15;;3908:6;3900;3893:22;3948:3;3939:6;3934:3;3930:16;3927:25;3924:45;;;3965:1;3962;3955:12;3924:45;4015:6;4010:3;4003:4;3995:6;3991:17;3978:44;4070:1;4063:4;4054:6;4046;4042:19;4038:30;4031:41;;;;3446:632;;;;;:::o;4083:451::-;4152:6;4205:2;4193:9;4184:7;4180:23;4176:32;4173:52;;;4221:1;4218;4211:12;4173:52;4261:9;4248:23;4294:18;4286:6;4283:30;4280:50;;;4326:1;4323;4316:12;4280:50;4349:22;;4402:4;4394:13;;4390:27;-1:-1:-1;4380:55:1;;4431:1;4428;4421:12;4380:55;4454:74;4520:7;4515:2;4502:16;4497:2;4493;4489:11;4454:74;:::i;4539:186::-;4598:6;4651:2;4639:9;4630:7;4626:23;4622:32;4619:52;;;4667:1;4664;4657:12;4619:52;4690:29;4709:9;4690:29;:::i;4730:248::-;4798:6;4806;4859:2;4847:9;4838:7;4834:23;4830:32;4827:52;;;4875:1;4872;4865:12;4827:52;-1:-1:-1;;4898:23:1;;;4968:2;4953:18;;;4940:32;;-1:-1:-1;4730:248:1:o;4983:347::-;5048:6;5056;5109:2;5097:9;5088:7;5084:23;5080:32;5077:52;;;5125:1;5122;5115:12;5077:52;5148:29;5167:9;5148:29;:::i;:::-;5138:39;;5227:2;5216:9;5212:18;5199:32;5274:5;5267:13;5260:21;5253:5;5250:32;5240:60;;5296:1;5293;5286:12;5240:60;5319:5;5309:15;;;4983:347;;;;;:::o;5335:667::-;5430:6;5438;5446;5454;5507:3;5495:9;5486:7;5482:23;5478:33;5475:53;;;5524:1;5521;5514:12;5475:53;5547:29;5566:9;5547:29;:::i;:::-;5537:39;;5595:38;5629:2;5618:9;5614:18;5595:38;:::i;:::-;5585:48;;5680:2;5669:9;5665:18;5652:32;5642:42;;5735:2;5724:9;5720:18;5707:32;5762:18;5754:6;5751:30;5748:50;;;5794:1;5791;5784:12;5748:50;5817:22;;5870:4;5862:13;;5858:27;-1:-1:-1;5848:55:1;;5899:1;5896;5889:12;5848:55;5922:74;5988:7;5983:2;5970:16;5965:2;5961;5957:11;5922:74;:::i;:::-;5912:84;;;5335:667;;;;;;;:::o;6007:260::-;6075:6;6083;6136:2;6124:9;6115:7;6111:23;6107:32;6104:52;;;6152:1;6149;6142:12;6104:52;6175:29;6194:9;6175:29;:::i;:::-;6165:39;;6223:38;6257:2;6246:9;6242:18;6223:38;:::i;6272:380::-;6351:1;6347:12;;;;6394;;;6415:61;;6469:4;6461:6;6457:17;6447:27;;6415:61;6522:2;6514:6;6511:14;6491:18;6488:38;6485:161;;6568:10;6563:3;6559:20;6556:1;6549:31;6603:4;6600:1;6593:15;6631:4;6628:1;6621:15;6485:161;;6272:380;;;:::o;7073:407::-;7275:2;7257:21;;;7314:2;7294:18;;;7287:30;7353:34;7348:2;7333:18;;7326:62;-1:-1:-1;;;7419:2:1;7404:18;;7397:41;7470:3;7455:19;;7073:407::o;7485:127::-;7546:10;7541:3;7537:20;7534:1;7527:31;7577:4;7574:1;7567:15;7601:4;7598:1;7591:15;7617:128;7657:3;7688:1;7684:6;7681:1;7678:13;7675:39;;;7694:18;;:::i;:::-;-1:-1:-1;7730:9:1;;7617:128::o;8806:470::-;8985:3;9023:6;9017:13;9039:53;9085:6;9080:3;9073:4;9065:6;9061:17;9039:53;:::i;:::-;9155:13;;9114:16;;;;9177:57;9155:13;9114:16;9211:4;9199:17;;9177:57;:::i;:::-;9250:20;;8806:470;-1:-1:-1;;;;8806:470:1:o;9688:489::-;-1:-1:-1;;;;;9957:15:1;;;9939:34;;10009:15;;10004:2;9989:18;;9982:43;10056:2;10041:18;;10034:34;;;10104:3;10099:2;10084:18;;10077:31;;;9882:4;;10125:46;;10151:19;;10143:6;10125:46;:::i;:::-;10117:54;9688:489;-1:-1:-1;;;;;;9688:489:1:o;10182:249::-;10251:6;10304:2;10292:9;10283:7;10279:23;10275:32;10272:52;;;10320:1;10317;10310:12;10272:52;10352:9;10346:16;10371:30;10395:5;10371:30;:::i;10436:135::-;10475:3;10496:17;;;10493:43;;10516:18;;:::i;:::-;-1:-1:-1;10563:1:1;10552:13;;10436:135::o;10576:127::-;10637:10;10632:3;10628:20;10625:1;10618:31;10668:4;10665:1;10658:15;10692:4;10689:1;10682:15;10708:120;10748:1;10774;10764:35;;10779:18;;:::i;:::-;-1:-1:-1;10813:9:1;;10708:120::o;10833:125::-;10873:4;10901:1;10898;10895:8;10892:34;;;10906:18;;:::i;:::-;-1:-1:-1;10943:9:1;;10833:125::o;10963:112::-;10995:1;11021;11011:35;;11026:18;;:::i;:::-;-1:-1:-1;11060:9:1;;10963:112::o;11080:127::-;11141:10;11136:3;11132:20;11129:1;11122:31;11172:4;11169:1;11162:15;11196:4;11193:1;11186:15;11212:786;11623:25;11618:3;11611:38;11593:3;11678:6;11672:13;11694:62;11749:6;11744:2;11739:3;11735:12;11728:4;11720:6;11716:17;11694:62;:::i;:::-;-1:-1:-1;;;11815:2:1;11775:16;;;11807:11;;;11800:40;11865:13;;11887:63;11865:13;11936:2;11928:11;;11921:4;11909:17;;11887:63;:::i;:::-;11970:17;11989:2;11966:26;;11212:786;-1:-1:-1;;;;11212:786:1:o;12003:168::-;12043:7;12109:1;12105;12101:6;12097:14;12094:1;12091:21;12086:1;12079:9;12072:17;12068:45;12065:71;;;12116:18;;:::i;:::-;-1:-1:-1;12156:9:1;;12003:168::o;12176:136::-;12215:3;12243:5;12233:39;;12252:18;;:::i;:::-;-1:-1:-1;;;12288:18:1;;12176:136::o;12678:127::-;12739:10;12734:3;12730:20;12727:1;12720:31;12770:4;12767:1;12760:15;12794:4;12791:1;12784:15

Swarm Source

ipfs://94ac6c6bb0d5c8d5362a1668cecc00da2164cbf0c26baa6eea620dfcb478eda8

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