Token

ERC-20: DarkSiteOfExistence (DSOENFT)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-721

Overview

Max Total Supply

333 DSOENFT

Holders

333

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xc2a37ba7201f29e774acbfd3dd3c143bce9c8a51

Filtered by Token Holder

0x98B9ce8Ed12af000dB03F44DDBb797ed376E2914

Balance

1 DSOENFT

0x98b9ce8ed12af000db03f44ddbb797ed376e2914

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

DarkSiteOfExistence

Compiler Version

v0.8.13+commit.abaa5c0e

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

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

// SPDX-License-Identifier: MIT

// ERC721A Contracts v3.3.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: https://github.com/chiru-labs/ERC721A/blob/main/contracts/ERC721A.sol


// ERC721A Contracts v3.3.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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Strings.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Context.sol


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

pragma solidity ^0.8.0;

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

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol


// 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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol


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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/IERC721Receiver.sol


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

pragma solidity ^0.8.0;

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/introspection/IERC165.sol


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

pragma solidity ^0.8.0;

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/introspection/ERC165.sol


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

pragma solidity ^0.8.0;


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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/IERC721.sol


// 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 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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/extensions/IERC721Metadata.sol


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

pragma solidity ^0.8.0;


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

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

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol


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

pragma solidity ^0.8.0;








/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: address zero is not a valid owner");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

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

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits an {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

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

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


pragma solidity ^0.8.0;


contract DarkSiteOfExistence is ERC721A, Ownable {

    using Strings for uint256;

    uint256 public price = 0.01 ether;

    uint256 public maxPerTx = 4;

    uint256 public maxFreePerTx = 1;

    uint256 public maxFreePerWallet = 1;

    uint256 public maxPerWallet = 5;

    uint256 public totalFree = 333;

    uint256 public mintedSupply = 0;

    uint256 public maxSupply = 999;

    bool public mintEnabled = false; //is mint enabled ?

    bool public revealed = true; //is revealed ?
    
    mapping(address => uint256) public mintedWallets;

    string public baseURI = "ipfs://QmVGUkHT9u3XjXBVaRpg41yg3HprPC7LhiaNJaSCQBBJsy/";


    constructor(
        string memory _uri
    ) ERC721A("DarkSiteOfExistence", "DSOENFT") {
        _uri = baseURI;
    }

    function toggleIsMintEnabled() external onlyOwner { 
        mintEnabled = !mintEnabled;
    }

    function isPublicMintEnabled() public view returns (bool) { 
        return mintEnabled;
    }
    function setMaxSupply(uint256 maxSupply_) external onlyOwner {
        maxSupply = maxSupply_;
    }
   
    function mint(uint256 quantity) external payable {

        uint256 cost = price;
        bool isFree = ((mintedSupply + quantity < totalFree + 1) &&
            (mintedWallets[msg.sender] + quantity <= maxFreePerWallet));

        if (isFree) {
            cost = 0;
            require(quantity < 3, "Max per TX is 2");
        } else {
            require(quantity < 6, "Max per TX is 5");
        }

        
        require(mintEnabled, "Minting is not live yet");
        require(msg.value >= quantity * cost, "Please send the exact amount.");
        require(mintedSupply + quantity < maxSupply + 1, "Sold out");
        require(mintedWallets[msg.sender] + quantity <= maxPerWallet, "Max 10 per wallet");

        mintedWallets[msg.sender] = mintedWallets[msg.sender] + quantity;
        mintedSupply = mintedSupply + quantity;

        _safeMint(msg.sender, quantity);


    }

    function getBalance() public view returns(uint) {
        return address(this).balance;
    }

    function withdrawMoney() public onlyOwner {
        address payable to = payable(msg.sender);
        to.transfer(getBalance());
    }

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

    function setPrice(uint256 newPrice) public onlyOwner {
        price = newPrice;
    }

    function setSupply(uint256 newSupply) public onlyOwner {
        maxSupply = newSupply;
    }

    function setFreeSupply(uint256 newSupply) public onlyOwner {
        totalFree = newSupply;
    }



    function tokenURI(uint256 _tokenId) public view override returns (string memory) {
        require(_exists(_tokenId), "Token does not exist.");
        return bytes(baseURI).length > 0 ? string(
            abi.encodePacked(
              baseURI,
              Strings.toString(_tokenId),
              ".json"
            )
        ) : "";
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_uri","type":"string"}],"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":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"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":[],"name":"getBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isPublicMintEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxFreePerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxFreePerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintedSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"mintedWallets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newSupply","type":"uint256"}],"name":"setFreeSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxSupply_","type":"uint256"}],"name":"setMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newSupply","type":"uint256"}],"name":"setSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toggleIsMintEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFree","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawMoney","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

662386f26fc100006009556004600a556001600b819055600c556005600d5561014d600e556000600f556103e76010556011805461ffff191661010017905560e0604052603660808181529062001f0560a0398051620000689160139160209091019062000213565b503480156200007657600080fd5b5060405162001f3b38038062001f3b8339810160408190526200009991620002cf565b604080518082018252601381527f4461726b536974654f664578697374656e6365000000000000000000000000006020808301918252835180850190945260078452661114d3d153919560ca1b908401528151919291620000fd9160029162000213565b5080516200011390600390602084019062000213565b505060008055506200012533620001c1565b601380546200013490620003ab565b80601f01602080910402602001604051908101604052809291908181526020018280546200016290620003ab565b8015620001b35780601f106200018757610100808354040283529160200191620001b3565b820191906000526020600020905b8154815290600101906020018083116200019557829003601f168201915b5050505050905050620003e7565b600880546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b8280546200022190620003ab565b90600052602060002090601f01602090048101928262000245576000855562000290565b82601f106200026057805160ff191683800117855562000290565b8280016001018555821562000290579182015b828111156200029057825182559160200191906001019062000273565b506200029e929150620002a2565b5090565b5b808211156200029e5760008155600101620002a3565b634e487b7160e01b600052604160045260246000fd5b60006020808385031215620002e357600080fd5b82516001600160401b0380821115620002fb57600080fd5b818501915085601f8301126200031057600080fd5b815181811115620003255762000325620002b9565b604051601f8201601f19908116603f01168101908382118183101715620003505762000350620002b9565b8160405282815288868487010111156200036957600080fd5b600093505b828410156200038d57848401860151818501870152928501926200036e565b828411156200039f5760008684830101525b98975050505050505050565b600181811c90821680620003c057607f821691505b602082108103620003e157634e487b7160e01b600052602260045260246000fd5b50919050565b611b0e80620003f76000396000f3fe6080604052600436106102255760003560e01c80638da5cb5b11610123578063b88d4fde116100ab578063d5abeb011161006f578063d5abeb01146105c9578063e985e9c5146105df578063f2fde38b14610628578063f676308a14610648578063f968adbe1461066857600080fd5b8063b88d4fde14610544578063c1bd8cf914610564578063c40732171461057a578063c87b56dd1461058f578063d1239730146105af57600080fd5b8063a0712d68116100f2578063a0712d68146104b9578063a22cb465146104cc578063a7027357146104ec578063ac44600214610502578063ada7c4ed1461051757600080fd5b80638da5cb5b1461045057806391b7f5ed1461046e57806395d89b411461048e578063a035b1fe146104a357600080fd5b80633b4c4b25116101b15780636c0360eb116101755780636c0360eb146103f05780636f8b44b01461035b57806370a0823114610405578063715018a6146104255780637dc949b21461043a57600080fd5b80633b4c4b251461035b57806342842e0e1461037b578063453c23101461039b57806351830227146103b15780636352211e146103d057600080fd5b8063095ea7b3116101f8578063095ea7b3146102cd57806312065fe0146102ef57806318160ddd1461030c57806323b872dd14610325578063333e44e61461034557600080fd5b80630116bc2d1461022a57806301ffc9a71461025357806306fdde0314610273578063081812fc14610295575b600080fd5b34801561023657600080fd5b5060115460ff165b60405190151581526020015b60405180910390f35b34801561025f57600080fd5b5061023e61026e3660046115c9565b61067e565b34801561027f57600080fd5b506102886106d0565b60405161024a919061163e565b3480156102a157600080fd5b506102b56102b0366004611651565b610762565b6040516001600160a01b03909116815260200161024a565b3480156102d957600080fd5b506102ed6102e8366004611686565b6107a6565b005b3480156102fb57600080fd5b50475b60405190815260200161024a565b34801561031857600080fd5b50600154600054036102fe565b34801561033157600080fd5b506102ed6103403660046116b0565b610878565b34801561035157600080fd5b506102fe600e5481565b34801561036757600080fd5b506102ed610376366004611651565b610888565b34801561038757600080fd5b506102ed6103963660046116b0565b6108c0565b3480156103a757600080fd5b506102fe600d5481565b3480156103bd57600080fd5b5060115461023e90610100900460ff1681565b3480156103dc57600080fd5b506102b56103eb366004611651565b6108db565b3480156103fc57600080fd5b506102886108e6565b34801561041157600080fd5b506102fe6104203660046116ec565b610974565b34801561043157600080fd5b506102ed6109c3565b34801561044657600080fd5b506102fe600b5481565b34801561045c57600080fd5b506008546001600160a01b03166102b5565b34801561047a57600080fd5b506102ed610489366004611651565b6109f9565b34801561049a57600080fd5b50610288610a28565b3480156104af57600080fd5b506102fe60095481565b6102ed6104c7366004611651565b610a37565b3480156104d857600080fd5b506102ed6104e7366004611707565b610cbc565b3480156104f857600080fd5b506102fe600c5481565b34801561050e57600080fd5b506102ed610d51565b34801561052357600080fd5b506102fe6105323660046116ec565b60126020526000908152604090205481565b34801561055057600080fd5b506102ed61055f366004611759565b610dad565b34801561057057600080fd5b506102fe600f5481565b34801561058657600080fd5b506102ed610df7565b34801561059b57600080fd5b506102886105aa366004611651565b610e35565b3480156105bb57600080fd5b5060115461023e9060ff1681565b3480156105d557600080fd5b506102fe60105481565b3480156105eb57600080fd5b5061023e6105fa366004611835565b6001600160a01b03918216600090815260076020908152604080832093909416825291909152205460ff1690565b34801561063457600080fd5b506102ed6106433660046116ec565b610ee0565b34801561065457600080fd5b506102ed610663366004611651565b610f7b565b34801561067457600080fd5b506102fe600a5481565b60006301ffc9a760e01b6001600160e01b0319831614806106af57506380ac58cd60e01b6001600160e01b03198316145b806106ca5750635b5e139f60e01b6001600160e01b03198316145b92915050565b6060600280546106df90611868565b80601f016020809104026020016040519081016040528092919081815260200182805461070b90611868565b80156107585780601f1061072d57610100808354040283529160200191610758565b820191906000526020600020905b81548152906001019060200180831161073b57829003601f168201915b5050505050905090565b600061076d82610faa565b61078a576040516333d1c03960e21b815260040160405180910390fd5b506000908152600660205260409020546001600160a01b031690565b60006107b182610fd1565b9050806001600160a01b0316836001600160a01b0316036107e55760405163250fdee360e21b815260040160405180910390fd5b336001600160a01b0382161461081c576107ff81336105fa565b61081c576040516367d9dca160e11b815260040160405180910390fd5b60008281526006602052604080822080546001600160a01b0319166001600160a01b0387811691821790925591518593918516917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591a4505050565b61088383838361103f565b505050565b6008546001600160a01b031633146108bb5760405162461bcd60e51b81526004016108b2906118a2565b60405180910390fd5b601055565b61088383838360405180602001604052806000815250610dad565b60006106ca82610fd1565b601380546108f390611868565b80601f016020809104026020016040519081016040528092919081815260200182805461091f90611868565b801561096c5780601f106109415761010080835404028352916020019161096c565b820191906000526020600020905b81548152906001019060200180831161094f57829003601f168201915b505050505081565b60006001600160a01b03821661099d576040516323d3ad8160e21b815260040160405180910390fd5b506001600160a01b031660009081526005602052604090205467ffffffffffffffff1690565b6008546001600160a01b031633146109ed5760405162461bcd60e51b81526004016108b2906118a2565b6109f760006111e6565b565b6008546001600160a01b03163314610a235760405162461bcd60e51b81526004016108b2906118a2565b600955565b6060600380546106df90611868565b600954600e54600090610a4b9060016118ed565b83600f54610a5991906118ed565b108015610a825750600c5433600090815260126020526040902054610a7f9085906118ed565b11155b90508015610ad5576000915060038310610ad05760405162461bcd60e51b815260206004820152600f60248201526e26b0bc103832b9102a2c1034b9901960891b60448201526064016108b2565b610b17565b60068310610b175760405162461bcd60e51b815260206004820152600f60248201526e4d617820706572205458206973203560881b60448201526064016108b2565b60115460ff16610b695760405162461bcd60e51b815260206004820152601760248201527f4d696e74696e67206973206e6f74206c6976652079657400000000000000000060448201526064016108b2565b610b738284611905565b341015610bc25760405162461bcd60e51b815260206004820152601d60248201527f506c656173652073656e642074686520657861637420616d6f756e742e00000060448201526064016108b2565b601054610bd09060016118ed565b83600f54610bde91906118ed565b10610c165760405162461bcd60e51b815260206004820152600860248201526714dbdb19081bdd5d60c21b60448201526064016108b2565b600d5433600090815260126020526040902054610c349085906118ed565b1115610c765760405162461bcd60e51b815260206004820152601160248201527013585e080c4c081c195c881dd85b1b195d607a1b60448201526064016108b2565b33600090815260126020526040902054610c919084906118ed565b33600090815260126020526040902055600f54610caf9084906118ed565b600f556108833384611238565b336001600160a01b03831603610ce55760405163b06307db60e01b815260040160405180910390fd5b3360008181526007602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b6008546001600160a01b03163314610d7b5760405162461bcd60e51b81526004016108b2906118a2565b33806108fc476040518115909202916000818181858888f19350505050158015610da9573d6000803e3d6000fd5b5050565b610db884848461103f565b6001600160a01b0383163b15610df157610dd484848484611252565b610df1576040516368d2bf6b60e11b815260040160405180910390fd5b50505050565b6008546001600160a01b03163314610e215760405162461bcd60e51b81526004016108b2906118a2565b6011805460ff19811660ff90911615179055565b6060610e4082610faa565b610e845760405162461bcd60e51b81526020600482015260156024820152742a37b5b2b7103237b2b9903737ba1032bc34b9ba1760591b60448201526064016108b2565b600060138054610e9390611868565b905011610eaf57604051806020016040528060008152506106ca565b6013610eba8361133e565b604051602001610ecb929190611940565b60405160208183030381529060405292915050565b6008546001600160a01b03163314610f0a5760405162461bcd60e51b81526004016108b2906118a2565b6001600160a01b038116610f6f5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016108b2565b610f78816111e6565b50565b6008546001600160a01b03163314610fa55760405162461bcd60e51b81526004016108b2906118a2565b600e55565b60008054821080156106ca575050600090815260046020526040902054600160e01b161590565b6000816000548110156110265760008181526004602052604081205490600160e01b82169003611024575b8060000361101d575060001901600081815260046020526040902054610ffc565b9392505050565b505b604051636f96cda160e11b815260040160405180910390fd5b600061104a82610fd1565b9050836001600160a01b0316816001600160a01b03161461107d5760405162a1148160e81b815260040160405180910390fd5b6000336001600160a01b038616148061109b575061109b85336105fa565b806110b65750336110ab84610762565b6001600160a01b0316145b9050806110d657604051632ce44b5f60e11b815260040160405180910390fd5b6001600160a01b0384166110fd57604051633a954ecd60e21b815260040160405180910390fd5b600083815260066020908152604080832080546001600160a01b03191690556001600160a01b038881168452600583528184208054600019019055871683528083208054600101905585835260049091528120600160e11b4260a01b871781179091558316900361119e5760018301600081815260046020526040812054900361119c57600054811461119c5760008181526004602052604090208390555b505b82846001600160a01b0316866001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a45050505050565b600880546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b610da982826040518060200160405280600081525061143f565b604051630a85bd0160e11b81526000906001600160a01b0385169063150b7a02906112879033908990889088906004016119fa565b6020604051808303816000875af19250505080156112c2575060408051601f3d908101601f191682019092526112bf91810190611a37565b60015b611320573d8080156112f0576040519150601f19603f3d011682016040523d82523d6000602084013e6112f5565b606091505b508051600003611318576040516368d2bf6b60e11b815260040160405180910390fd5b805181602001fd5b6001600160e01b031916630a85bd0160e11b1490505b949350505050565b6060816000036113655750506040805180820190915260018152600360fc1b602082015290565b8160005b811561138f578061137981611a54565b91506113889050600a83611a83565b9150611369565b60008167ffffffffffffffff8111156113aa576113aa611743565b6040519080825280601f01601f1916602001820160405280156113d4576020820181803683370190505b5090505b8415611336576113e9600183611a97565b91506113f6600a86611aae565b6114019060306118ed565b60f81b81838151811061141657611416611ac2565b60200101906001600160f81b031916908160001a905350611438600a86611a83565b94506113d8565b6000546001600160a01b03841661146857604051622e076360e81b815260040160405180910390fd5b826000036114895760405163b562e8dd60e01b815260040160405180910390fd5b6001600160a01b03841660008181526005602090815260408083208054680100000000000000018902019055848352600490915290204260a01b86176001861460e11b1790558190818501903b1561155e575b60405182906001600160a01b038816906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a46115276000878480600101955087611252565b611544576040516368d2bf6b60e11b815260040160405180910390fd5b8082106114dc57826000541461155957600080fd5b6115a3565b5b6040516001830192906001600160a01b038816906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a480821061155f575b506000908155610df19085838684565b6001600160e01b031981168114610f7857600080fd5b6000602082840312156115db57600080fd5b813561101d816115b3565b60005b838110156116015781810151838201526020016115e9565b83811115610df15750506000910152565b6000815180845261162a8160208601602086016115e6565b601f01601f19169290920160200192915050565b60208152600061101d6020830184611612565b60006020828403121561166357600080fd5b5035919050565b80356001600160a01b038116811461168157600080fd5b919050565b6000806040838503121561169957600080fd5b6116a28361166a565b946020939093013593505050565b6000806000606084860312156116c557600080fd5b6116ce8461166a565b92506116dc6020850161166a565b9150604084013590509250925092565b6000602082840312156116fe57600080fd5b61101d8261166a565b6000806040838503121561171a57600080fd5b6117238361166a565b91506020830135801515811461173857600080fd5b809150509250929050565b634e487b7160e01b600052604160045260246000fd5b6000806000806080858703121561176f57600080fd5b6117788561166a565b93506117866020860161166a565b925060408501359150606085013567ffffffffffffffff808211156117aa57600080fd5b818701915087601f8301126117be57600080fd5b8135818111156117d0576117d0611743565b604051601f8201601f19908116603f011681019083821181831017156117f8576117f8611743565b816040528281528a602084870101111561181157600080fd5b82602086016020830137600060208483010152809550505050505092959194509250565b6000806040838503121561184857600080fd5b6118518361166a565b915061185f6020840161166a565b90509250929050565b600181811c9082168061187c57607f821691505b60208210810361189c57634e487b7160e01b600052602260045260246000fd5b50919050565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b634e487b7160e01b600052601160045260246000fd5b60008219821115611900576119006118d7565b500190565b600081600019048311821515161561191f5761191f6118d7565b500290565b600081516119368185602086016115e6565b9290920192915050565b600080845481600182811c91508083168061195c57607f831692505b6020808410820361197b57634e487b7160e01b86526022600452602486fd5b81801561198f57600181146119a0576119cd565b60ff198616895284890196506119cd565b60008b81526020902060005b868110156119c55781548b8201529085019083016119ac565b505084890196505b5050505050506119f16119e08286611924565b64173539b7b760d91b815260050190565b95945050505050565b6001600160a01b0385811682528416602082015260408101839052608060608201819052600090611a2d90830184611612565b9695505050505050565b600060208284031215611a4957600080fd5b815161101d816115b3565b600060018201611a6657611a666118d7565b5060010190565b634e487b7160e01b600052601260045260246000fd5b600082611a9257611a92611a6d565b500490565b600082821015611aa957611aa96118d7565b500390565b600082611abd57611abd611a6d565b500690565b634e487b7160e01b600052603260045260246000fdfea26469706673582212200168e9c289bcf70dc881d169bff704bc8f2a87674b22ff1f8e81d01aebccef0a64736f6c634300080d0033697066733a2f2f516d5647556b4854397533586a5842566152706734317967334870725043374c6869614e4a6153435142424a73792f00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000

Deployed Bytecode

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

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

00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _uri (string): 

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

76546:3082:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77457:96;;;;;;;;;;-1:-1:-1;77534:11:0;;;;77457:96;;;179:14:1;;172:22;154:41;;142:2;127:18;77457:96:0;;;;;;;;13103:615;;;;;;;;;;-1:-1:-1;13103:615:0;;;;;:::i;:::-;;:::i;18116:100::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;20184:204::-;;;;;;;;;;-1:-1:-1;20184:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1714:32:1;;;1696:51;;1684:2;1669:18;20184:204:0;1550:203:1;19644:474:0;;;;;;;;;;-1:-1:-1;19644:474:0;;;;;:::i;:::-;;:::i;:::-;;78589:95;;;;;;;;;;-1:-1:-1;78655:21:0;78589:95;;;2341:25:1;;;2329:2;2314:18;78589:95:0;2195:177:1;12157:315:0;;;;;;;;;;-1:-1:-1;12423:12:0;;12210:7;12407:13;:28;12157:315;;21070:170;;;;;;;;;;-1:-1:-1;21070:170:0;;;;;:::i;:::-;;:::i;76840:30::-;;;;;;;;;;;;;;;;79055:95;;;;;;;;;;-1:-1:-1;79055:95:0;;;;;:::i;:::-;;:::i;21311:185::-;;;;;;;;;;-1:-1:-1;21311:185:0;;;;;:::i;:::-;;:::i;76800:31::-;;;;;;;;;;;;;;;;77018:27;;;;;;;;;;-1:-1:-1;77018:27:0;;;;;;;;;;;17905:144;;;;;;;;;;-1:-1:-1;17905:144:0;;;;;:::i;:::-;;:::i;77131:80::-;;;;;;;;;;;;;:::i;13782:224::-;;;;;;;;;;-1:-1:-1;13782:224:0;;;;;:::i;:::-;;:::i;43624:103::-;;;;;;;;;;;;;:::i;76716:31::-;;;;;;;;;;;;;;;;42973:87;;;;;;;;;;-1:-1:-1;43046:6:0;;-1:-1:-1;;;;;43046:6:0;42973:87;;78959:88;;;;;;;;;;-1:-1:-1;78959:88:0;;;;;:::i;:::-;;:::i;18285:104::-;;;;;;;;;;;;;:::i;76638:33::-;;;;;;;;;;;;;;;;77672:909;;;;;;:::i;:::-;;:::i;20460:308::-;;;;;;;;;;-1:-1:-1;20460:308:0;;;;;:::i;:::-;;:::i;76756:35::-;;;;;;;;;;;;;;;;78692:137;;;;;;;;;;;;;:::i;77074:48::-;;;;;;;;;;-1:-1:-1;77074:48:0;;;;;:::i;:::-;;;;;;;;;;;;;;21567:396;;;;;;;;;;-1:-1:-1;21567:396:0;;;;;:::i;:::-;;:::i;76879:31::-;;;;;;;;;;;;;;;;77353:96;;;;;;;;;;;;;:::i;79269:356::-;;;;;;;;;;-1:-1:-1;79269:356:0;;;;;:::i;:::-;;:::i;76958:31::-;;;;;;;;;;-1:-1:-1;76958:31:0;;;;;;;;76919:30;;;;;;;;;;;;;;;;20839:164;;;;;;;;;;-1:-1:-1;20839:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;20960:25:0;;;20936:4;20960:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;20839:164;43882:201;;;;;;;;;;-1:-1:-1;43882:201:0;;;;;:::i;:::-;;:::i;79158:99::-;;;;;;;;;;-1:-1:-1;79158:99:0;;;;;:::i;:::-;;:::i;76680:27::-;;;;;;;;;;;;;;;;13103:615;13188:4;-1:-1:-1;;;;;;;;;13488:25:0;;;;:102;;-1:-1:-1;;;;;;;;;;13565:25:0;;;13488:102;:179;;;-1:-1:-1;;;;;;;;;;13642:25:0;;;13488:179;13468:199;13103:615;-1:-1:-1;;13103:615:0:o;18116:100::-;18170:13;18203:5;18196:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18116:100;:::o;20184:204::-;20252:7;20277:16;20285:7;20277;:16::i;:::-;20272:64;;20302:34;;-1:-1:-1;;;20302:34:0;;;;;;;;;;;20272:64;-1:-1:-1;20356:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;20356:24:0;;20184:204::o;19644:474::-;19717:13;19749:27;19768:7;19749:18;:27::i;:::-;19717:61;;19799:5;-1:-1:-1;;;;;19793:11:0;:2;-1:-1:-1;;;;;19793:11:0;;19789:48;;19813:24;;-1:-1:-1;;;19813:24:0;;;;;;;;;;;19789:48;36287:10;-1:-1:-1;;;;;19854:28:0;;;19850:175;;19902:44;19919:5;36287:10;20839:164;:::i;19902:44::-;19897:128;;19974:35;;-1:-1:-1;;;19974:35:0;;;;;;;;;;;19897:128;20037:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;20037:29:0;-1:-1:-1;;;;;20037:29:0;;;;;;;;;20082:28;;20037:24;;20082:28;;;;;;;19706:412;19644:474;;:::o;21070:170::-;21204:28;21214:4;21220:2;21224:7;21204:9;:28::i;:::-;21070:170;;;:::o;79055:95::-;43046:6;;-1:-1:-1;;;;;43046:6:0;36287:10;43193:23;43185:68;;;;-1:-1:-1;;;43185:68:0;;;;;;;:::i;:::-;;;;;;;;;79121:9:::1;:21:::0;79055:95::o;21311:185::-;21449:39;21466:4;21472:2;21476:7;21449:39;;;;;;;;;;;;:16;:39::i;17905:144::-;17969:7;18012:27;18031:7;18012:18;:27::i;77131:80::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;13782:224::-;13846:7;-1:-1:-1;;;;;13870:19:0;;13866:60;;13898:28;;-1:-1:-1;;;13898:28:0;;;;;;;;;;;13866:60;-1:-1:-1;;;;;;13944:25:0;;;;;:18;:25;;;;;;9121:13;13944:54;;13782:224::o;43624:103::-;43046:6;;-1:-1:-1;;;;;43046:6:0;36287:10;43193:23;43185:68;;;;-1:-1:-1;;;43185:68:0;;;;;;;:::i;:::-;43689:30:::1;43716:1;43689:18;:30::i;:::-;43624:103::o:0;78959:88::-;43046:6;;-1:-1:-1;;;;;43046:6:0;36287:10;43193:23;43185:68;;;;-1:-1:-1;;;43185:68:0;;;;;;;:::i;:::-;79023:5:::1;:16:::0;78959:88::o;18285:104::-;18341:13;18374:7;18367:14;;;;;:::i;77672:909::-;77749:5;;77807:9;;77734:12;;77807:13;;77819:1;77807:13;:::i;:::-;77796:8;77781:12;;:23;;;;:::i;:::-;:39;77780:116;;;;-1:-1:-1;77879:16:0;;77853:10;77839:25;;;;:13;:25;;;;;;:36;;77867:8;;77839:36;:::i;:::-;:56;;77780:116;77765:132;;77914:6;77910:175;;;77944:1;77937:8;;77979:1;77968:8;:12;77960:40;;;;-1:-1:-1;;;77960:40:0;;6006:2:1;77960:40:0;;;5988:21:1;6045:2;6025:18;;;6018:30;-1:-1:-1;;;6064:18:1;;;6057:45;6119:18;;77960:40:0;5804:339:1;77960:40:0;77910:175;;;78052:1;78041:8;:12;78033:40;;;;-1:-1:-1;;;78033:40:0;;6350:2:1;78033:40:0;;;6332:21:1;6389:2;6369:18;;;6362:30;-1:-1:-1;;;6408:18:1;;;6401:45;6463:18;;78033:40:0;6148:339:1;78033:40:0;78115:11;;;;78107:47;;;;-1:-1:-1;;;78107:47:0;;6694:2:1;78107:47:0;;;6676:21:1;6733:2;6713:18;;;6706:30;6772:25;6752:18;;;6745:53;6815:18;;78107:47:0;6492:347:1;78107:47:0;78186:15;78197:4;78186:8;:15;:::i;:::-;78173:9;:28;;78165:70;;;;-1:-1:-1;;;78165:70:0;;7219:2:1;78165:70:0;;;7201:21:1;7258:2;7238:18;;;7231:30;7297:31;7277:18;;;7270:59;7346:18;;78165:70:0;7017:353:1;78165:70:0;78280:9;;:13;;78292:1;78280:13;:::i;:::-;78269:8;78254:12;;:23;;;;:::i;:::-;:39;78246:60;;;;-1:-1:-1;;;78246:60:0;;7577:2:1;78246:60:0;;;7559:21:1;7616:1;7596:18;;;7589:29;-1:-1:-1;;;7634:18:1;;;7627:38;7682:18;;78246:60:0;7375:331:1;78246:60:0;78365:12;;78339:10;78325:25;;;;:13;:25;;;;;;:36;;78353:8;;78325:36;:::i;:::-;:52;;78317:82;;;;-1:-1:-1;;;78317:82:0;;7913:2:1;78317:82:0;;;7895:21:1;7952:2;7932:18;;;7925:30;-1:-1:-1;;;7971:18:1;;;7964:47;8028:18;;78317:82:0;7711:341:1;78317:82:0;78454:10;78440:25;;;;:13;:25;;;;;;:36;;78468:8;;78440:36;:::i;:::-;78426:10;78412:25;;;;:13;:25;;;;;:64;78502:12;;:23;;78517:8;;78502:23;:::i;:::-;78487:12;:38;78538:31;78548:10;78560:8;78538:9;:31::i;20460:308::-;36287:10;-1:-1:-1;;;;;20559:31:0;;;20555:61;;20599:17;;-1:-1:-1;;;20599:17:0;;;;;;;;;;;20555:61;36287:10;20629:39;;;;:18;:39;;;;;;;;-1:-1:-1;;;;;20629:49:0;;;;;;;;;;;;:60;;-1:-1:-1;;20629:60:0;;;;;;;;;;20705:55;;154:41:1;;;20629:49:0;;36287:10;20705:55;;127:18:1;20705:55:0;;;;;;;20460:308;;:::o;78692:137::-;43046:6;;-1:-1:-1;;;;;43046:6:0;36287:10;43193:23;43185:68;;;;-1:-1:-1;;;43185:68:0;;;;;;;:::i;:::-;78774:10:::1;::::0;78796:25:::1;78655:21:::0;78796:25:::1;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;78734:95;78692:137::o:0;21567:396::-;21734:28;21744:4;21750:2;21754:7;21734:9;:28::i;:::-;-1:-1:-1;;;;;21777:14:0;;;:19;21773:183;;21816:56;21847:4;21853:2;21857:7;21866:5;21816:30;:56::i;:::-;21811:145;;21900:40;;-1:-1:-1;;;21900:40:0;;;;;;;;;;;21811:145;21567:396;;;;:::o;77353:96::-;43046:6;;-1:-1:-1;;;;;43046:6:0;36287:10;43193:23;43185:68;;;;-1:-1:-1;;;43185:68:0;;;;;;;:::i;:::-;77430:11:::1;::::0;;-1:-1:-1;;77415:26:0;::::1;77430:11;::::0;;::::1;77429:12;77415:26;::::0;;77353:96::o;79269:356::-;79335:13;79369:17;79377:8;79369:7;:17::i;:::-;79361:51;;;;-1:-1:-1;;;79361:51:0;;8259:2:1;79361:51:0;;;8241:21:1;8298:2;8278:18;;;8271:30;-1:-1:-1;;;8317:18:1;;;8310:51;8378:18;;79361:51:0;8057:345:1;79361:51:0;79454:1;79436:7;79430:21;;;;;:::i;:::-;;;:25;:187;;;;;;;;;;;;;;;;;79512:7;79536:26;79553:8;79536:16;:26::i;:::-;79479:122;;;;;;;;;:::i;:::-;;;;;;;;;;;;;79423:194;79269:356;-1:-1:-1;;79269:356:0:o;43882:201::-;43046:6;;-1:-1:-1;;;;;43046:6:0;36287:10;43193:23;43185:68;;;;-1:-1:-1;;;43185:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;43971:22:0;::::1;43963:73;;;::::0;-1:-1:-1;;;43963:73:0;;10349:2:1;43963:73:0::1;::::0;::::1;10331:21:1::0;10388:2;10368:18;;;10361:30;10427:34;10407:18;;;10400:62;-1:-1:-1;;;10478:18:1;;;10471:36;10524:19;;43963:73:0::1;10147:402:1::0;43963:73:0::1;44047:28;44066:8;44047:18;:28::i;:::-;43882:201:::0;:::o;79158:99::-;43046:6;;-1:-1:-1;;;;;43046:6:0;36287:10;43193:23;43185:68;;;;-1:-1:-1;;;43185:68:0;;;;;;;:::i;:::-;79228:9:::1;:21:::0;79158:99::o;22218:273::-;22275:4;22365:13;;22355:7;:23;22312:152;;;;-1:-1:-1;;22416:26:0;;;;:17;:26;;;;;;-1:-1:-1;;;22416:43:0;:48;;22218:273::o;15420:1129::-;15487:7;15522;15624:13;;15617:4;:20;15613:869;;;15662:14;15679:23;;;:17;:23;;;;;;;-1:-1:-1;;;15768:23:0;;:28;;15764:699;;16287:113;16294:6;16304:1;16294:11;16287:113;;-1:-1:-1;;;16365:6:0;16347:25;;;;:17;:25;;;;;;16287:113;;;16433:6;15420:1129;-1:-1:-1;;;15420:1129:0:o;15764:699::-;15639:843;15613:869;16510:31;;-1:-1:-1;;;16510:31:0;;;;;;;;;;;27457:2515;27572:27;27602;27621:7;27602:18;:27::i;:::-;27572:57;;27687:4;-1:-1:-1;;;;;27646:45:0;27662:19;-1:-1:-1;;;;;27646:45:0;;27642:86;;27700:28;;-1:-1:-1;;;27700:28:0;;;;;;;;;;;27642:86;27741:22;36287:10;-1:-1:-1;;;;;27767:27:0;;;;:87;;-1:-1:-1;27811:43:0;27828:4;36287:10;20839:164;:::i;27811:43::-;27767:147;;;-1:-1:-1;36287:10:0;27871:20;27883:7;27871:11;:20::i;:::-;-1:-1:-1;;;;;27871:43:0;;27767:147;27741:174;;27933:17;27928:66;;27959:35;;-1:-1:-1;;;27959:35:0;;;;;;;;;;;27928:66;-1:-1:-1;;;;;28009:16:0;;28005:52;;28034:23;;-1:-1:-1;;;28034:23:0;;;;;;;;;;;28005:52;28186:24;;;;:15;:24;;;;;;;;28179:31;;-1:-1:-1;;;;;;28179:31:0;;;-1:-1:-1;;;;;28578:24:0;;;;;:18;:24;;;;;28576:26;;-1:-1:-1;;28576:26:0;;;28647:22;;;;;;;28645:24;;-1:-1:-1;28645:24:0;;;28940:26;;;:17;:26;;;;;-1:-1:-1;;;29028:15:0;9775:3;29028:41;28986:84;;:128;;28940:174;;;29234:46;;:51;;29230:626;;29338:1;29328:11;;29306:19;29461:30;;;:17;:30;;;;;;:35;;29457:384;;29599:13;;29584:11;:28;29580:242;;29746:30;;;;:17;:30;;;;;:52;;;29580:242;29287:569;29230:626;29903:7;29899:2;-1:-1:-1;;;;;29884:27:0;29893:4;-1:-1:-1;;;;;29884:27:0;;;;;;;;;;;27561:2411;;27457:2515;;;:::o;44243:191::-;44336:6;;;-1:-1:-1;;;;;44353:17:0;;;-1:-1:-1;;;;;;44353:17:0;;;;;;;44386:40;;44336:6;;;44353:17;44336:6;;44386:40;;44317:16;;44386:40;44306:128;44243:191;:::o;22575:104::-;22644:27;22654:2;22658:8;22644:27;;;;;;;;;;;;:9;:27::i;33669:716::-;33853:88;;-1:-1:-1;;;33853:88:0;;33832:4;;-1:-1:-1;;;;;33853:45:0;;;;;:88;;36287:10;;33920:4;;33926:7;;33935:5;;33853:88;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;33853:88:0;;;;;;;;-1:-1:-1;;33853:88:0;;;;;;;;;;;;:::i;:::-;;;33849:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34136:6;:13;34153:1;34136:18;34132:235;;34182:40;;-1:-1:-1;;;34182:40:0;;;;;;;;;;;34132:235;34325:6;34319:13;34310:6;34306:2;34302:15;34295:38;33849:529;-1:-1:-1;;;;;;34012:64:0;-1:-1:-1;;;34012:64:0;;-1:-1:-1;33849:529:0;33669:716;;;;;;:::o;38845:723::-;38901:13;39122:5;39131:1;39122:10;39118:53;;-1:-1:-1;;39149:10:0;;;;;;;;;;;;-1:-1:-1;;;39149:10:0;;;;;38845:723::o;39118:53::-;39196:5;39181:12;39237:78;39244:9;;39237:78;;39270:8;;;;:::i;:::-;;-1:-1:-1;39293:10:0;;-1:-1:-1;39301:2:0;39293:10;;:::i;:::-;;;39237:78;;;39325:19;39357:6;39347:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;39347:17:0;;39325:39;;39375:154;39382:10;;39375:154;;39409:11;39419:1;39409:11;;:::i;:::-;;-1:-1:-1;39478:10:0;39486:2;39478:5;:10;:::i;:::-;39465:24;;:2;:24;:::i;:::-;39452:39;;39435:6;39442;39435:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;39435:56:0;;;;;;;;-1:-1:-1;39506:11:0;39515:2;39506:11;;:::i;:::-;;;39375:154;;23052:2236;23175:20;23198:13;-1:-1:-1;;;;;23226:16:0;;23222:48;;23251:19;;-1:-1:-1;;;23251:19:0;;;;;;;;;;;23222:48;23285:8;23297:1;23285:13;23281:44;;23307:18;;-1:-1:-1;;;23307:18:0;;;;;;;;;;;23281:44;-1:-1:-1;;;;;23874:22:0;;;;;;:18;:22;;;;9258:2;23874:22;;;:70;;23912:31;23900:44;;23874:70;;;24187:31;;;:17;:31;;;;;24280:15;9775:3;24280:41;24238:84;;-1:-1:-1;24358:13:0;;10038:3;24343:56;24238:162;24187:213;;:31;;24481:23;;;;24525:14;:19;24521:635;;24565:313;24596:38;;24621:12;;-1:-1:-1;;;;;24596:38:0;;;24613:1;;24596:38;;24613:1;;24596:38;24662:69;24701:1;24705:2;24709:14;;;;;;24725:5;24662:30;:69::i;:::-;24657:174;;24767:40;;-1:-1:-1;;;24767:40:0;;;;;;;;;;;24657:174;24873:3;24858:12;:18;24565:313;;24959:12;24942:13;;:29;24938:43;;24973:8;;;24938:43;24521:635;;;25022:119;25053:40;;25078:14;;;;;-1:-1:-1;;;;;25053:40:0;;;25070:1;;25053:40;;25070:1;;25053:40;25136:3;25121:12;:18;25022:119;;24521:635;-1:-1:-1;25170:13:0;:28;;;25220:60;;25253:2;25257:12;25271:8;25220:60;:::i;206:131:1:-;-1:-1:-1;;;;;;280:32:1;;270:43;;260:71;;327:1;324;317:12;342:245;400:6;453:2;441:9;432:7;428:23;424:32;421:52;;;469:1;466;459:12;421:52;508:9;495:23;527:30;551:5;527: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:269::-;908:3;946:5;940:12;973:6;968:3;961:19;989:63;1045:6;1038:4;1033:3;1029:14;1022:4;1015:5;1011:16;989:63;:::i;:::-;1106:2;1085:15;-1:-1:-1;;1081:29:1;1072:39;;;;1113:4;1068:50;;855:269;-1:-1:-1;;855:269:1:o;1129:231::-;1278:2;1267:9;1260:21;1241:4;1298:56;1350:2;1339:9;1335:18;1327:6;1298:56;:::i;1365:180::-;1424:6;1477:2;1465:9;1456:7;1452:23;1448:32;1445:52;;;1493:1;1490;1483:12;1445:52;-1:-1:-1;1516:23:1;;1365:180;-1:-1:-1;1365:180:1:o;1758:173::-;1826:20;;-1:-1:-1;;;;;1875:31:1;;1865:42;;1855:70;;1921:1;1918;1911:12;1855:70;1758:173;;;:::o;1936:254::-;2004:6;2012;2065:2;2053:9;2044:7;2040:23;2036:32;2033:52;;;2081:1;2078;2071:12;2033:52;2104:29;2123:9;2104:29;:::i;:::-;2094:39;2180:2;2165:18;;;;2152:32;;-1:-1:-1;;;1936:254:1:o;2377:328::-;2454:6;2462;2470;2523:2;2511:9;2502:7;2498:23;2494:32;2491:52;;;2539:1;2536;2529:12;2491:52;2562:29;2581:9;2562:29;:::i;:::-;2552:39;;2610:38;2644:2;2633:9;2629:18;2610:38;:::i;:::-;2600:48;;2695:2;2684:9;2680:18;2667:32;2657:42;;2377:328;;;;;:::o;2710:186::-;2769:6;2822:2;2810:9;2801:7;2797:23;2793:32;2790:52;;;2838:1;2835;2828:12;2790:52;2861:29;2880:9;2861:29;:::i;2901:347::-;2966:6;2974;3027:2;3015:9;3006:7;3002:23;2998:32;2995:52;;;3043:1;3040;3033:12;2995:52;3066:29;3085:9;3066:29;:::i;:::-;3056:39;;3145:2;3134:9;3130:18;3117:32;3192:5;3185:13;3178:21;3171:5;3168:32;3158:60;;3214:1;3211;3204:12;3158:60;3237:5;3227:15;;;2901:347;;;;;:::o;3253:127::-;3314:10;3309:3;3305:20;3302:1;3295:31;3345:4;3342:1;3335:15;3369:4;3366:1;3359:15;3385:1138;3480:6;3488;3496;3504;3557:3;3545:9;3536:7;3532:23;3528:33;3525:53;;;3574:1;3571;3564:12;3525:53;3597:29;3616:9;3597:29;:::i;:::-;3587:39;;3645:38;3679:2;3668:9;3664:18;3645:38;:::i;:::-;3635:48;;3730:2;3719:9;3715:18;3702:32;3692:42;;3785:2;3774:9;3770:18;3757:32;3808:18;3849:2;3841:6;3838:14;3835:34;;;3865:1;3862;3855:12;3835:34;3903:6;3892:9;3888:22;3878:32;;3948:7;3941:4;3937:2;3933:13;3929:27;3919:55;;3970:1;3967;3960:12;3919:55;4006:2;3993:16;4028:2;4024;4021:10;4018:36;;;4034:18;;:::i;:::-;4109:2;4103:9;4077:2;4163:13;;-1:-1:-1;;4159:22:1;;;4183:2;4155:31;4151:40;4139:53;;;4207:18;;;4227:22;;;4204:46;4201:72;;;4253:18;;:::i;:::-;4293:10;4289:2;4282:22;4328:2;4320:6;4313:18;4368:7;4363:2;4358;4354;4350:11;4346:20;4343:33;4340:53;;;4389:1;4386;4379:12;4340:53;4445:2;4440;4436;4432:11;4427:2;4419:6;4415:15;4402:46;4490:1;4485:2;4480;4472:6;4468:15;4464:24;4457:35;4511:6;4501:16;;;;;;;3385:1138;;;;;;;:::o;4528:260::-;4596:6;4604;4657:2;4645:9;4636:7;4632:23;4628:32;4625:52;;;4673:1;4670;4663:12;4625:52;4696:29;4715:9;4696:29;:::i;:::-;4686:39;;4744:38;4778:2;4767:9;4763:18;4744:38;:::i;:::-;4734:48;;4528:260;;;;;:::o;4793:380::-;4872:1;4868:12;;;;4915;;;4936:61;;4990:4;4982:6;4978:17;4968:27;;4936:61;5043:2;5035:6;5032:14;5012:18;5009:38;5006:161;;5089:10;5084:3;5080:20;5077:1;5070:31;5124:4;5121:1;5114:15;5152:4;5149:1;5142:15;5006:161;;4793:380;;;:::o;5178:356::-;5380:2;5362:21;;;5399:18;;;5392:30;5458:34;5453:2;5438:18;;5431:62;5525:2;5510:18;;5178:356::o;5539:127::-;5600:10;5595:3;5591:20;5588:1;5581:31;5631:4;5628:1;5621:15;5655:4;5652:1;5645:15;5671:128;5711:3;5742:1;5738:6;5735:1;5732:13;5729:39;;;5748:18;;:::i;:::-;-1:-1:-1;5784:9:1;;5671:128::o;6844:168::-;6884:7;6950:1;6946;6942:6;6938:14;6935:1;6932:21;6927:1;6920:9;6913:17;6909:45;6906:71;;;6957:18;;:::i;:::-;-1:-1:-1;6997:9:1;;6844:168::o;8533:185::-;8575:3;8613:5;8607:12;8628:52;8673:6;8668:3;8661:4;8654:5;8650:16;8628:52;:::i;:::-;8696:16;;;;;8533:185;-1:-1:-1;;8533:185:1:o;8841:1301::-;9118:3;9147:1;9180:6;9174:13;9210:3;9232:1;9260:9;9256:2;9252:18;9242:28;;9320:2;9309:9;9305:18;9342;9332:61;;9386:4;9378:6;9374:17;9364:27;;9332:61;9412:2;9460;9452:6;9449:14;9429:18;9426:38;9423:165;;-1:-1:-1;;;9487:33:1;;9543:4;9540:1;9533:15;9573:4;9494:3;9561:17;9423:165;9604:18;9631:104;;;;9749:1;9744:320;;;;9597:467;;9631:104;-1:-1:-1;;9664:24:1;;9652:37;;9709:16;;;;-1:-1:-1;9631:104:1;;9744:320;8480:1;8473:14;;;8517:4;8504:18;;9839:1;9853:165;9867:6;9864:1;9861:13;9853:165;;;9945:14;;9932:11;;;9925:35;9988:16;;;;9882:10;;9853:165;;;9857:3;;10047:6;10042:3;10038:16;10031:23;;9597:467;;;;;;;10080:56;10105:30;10131:3;10123:6;10105:30;:::i;:::-;-1:-1:-1;;;8783:20:1;;8828:1;8819:11;;8723:113;10080:56;10073:63;8841:1301;-1:-1:-1;;;;;8841:1301:1:o;10554:500::-;-1:-1:-1;;;;;10823:15:1;;;10805:34;;10875:15;;10870:2;10855:18;;10848:43;10922:2;10907:18;;10900:34;;;10970:3;10965:2;10950:18;;10943:31;;;10748:4;;10991:57;;11028:19;;11020:6;10991:57;:::i;:::-;10983:65;10554:500;-1:-1:-1;;;;;;10554:500:1:o;11059:249::-;11128:6;11181:2;11169:9;11160:7;11156:23;11152:32;11149:52;;;11197:1;11194;11187:12;11149:52;11229:9;11223:16;11248:30;11272:5;11248:30;:::i;11313:135::-;11352:3;11373:17;;;11370:43;;11393:18;;:::i;:::-;-1:-1:-1;11440:1:1;11429:13;;11313:135::o;11453:127::-;11514:10;11509:3;11505:20;11502:1;11495:31;11545:4;11542:1;11535:15;11569:4;11566:1;11559:15;11585:120;11625:1;11651;11641:35;;11656:18;;:::i;:::-;-1:-1:-1;11690:9:1;;11585:120::o;11710:125::-;11750:4;11778:1;11775;11772:8;11769:34;;;11783:18;;:::i;:::-;-1:-1:-1;11820:9:1;;11710:125::o;11840:112::-;11872:1;11898;11888:35;;11903:18;;:::i;:::-;-1:-1:-1;11937:9:1;;11840:112::o;11957:127::-;12018:10;12013:3;12009:20;12006:1;11999:31;12049:4;12046:1;12039:15;12073:4;12070:1;12063:15

Swarm Source

ipfs://0168e9c289bcf70dc881d169bff704bc8f2a87674b22ff1f8e81d01aebccef0a

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