Token

Shimai (Shimai)

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

ERC-721

Overview

Max Total Supply

115 Shimai

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x6673997ff5596158a5b499135fbe452488eea665

Filtered by Token Holder

0xc744ac15d868056a3bE8641c48Df76f42DB2D50A

Balance

2 Shimai

0xc744ac15d868056a3be8641c48df76f42db2d50a

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Shimai

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-12-13
*/

// SPDX-License-Identifier: MIT

// File contracts/OperatorFilter/IOperatorFilterRegistry.sol

pragma solidity ^0.8.13;

interface IOperatorFilterRegistry {
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);
    function register(address registrant) external;
    function registerAndSubscribe(address registrant, address subscription) external;
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;
    function unregister(address addr) external;
    function updateOperator(address registrant, address operator, bool filtered) external;
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
    function subscribe(address registrant, address registrantToSubscribe) external;
    function unsubscribe(address registrant, bool copyExistingEntries) external;
    function subscriptionOf(address addr) external returns (address registrant);
    function subscribers(address registrant) external returns (address[] memory);
    function subscriberAt(address registrant, uint256 index) external returns (address);
    function copyEntriesOf(address registrant, address registrantToCopy) external;
    function isOperatorFiltered(address registrant, address operator) external returns (bool);
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
    function filteredOperators(address addr) external returns (address[] memory);
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
    function isRegistered(address addr) external returns (bool);
    function codeHashOf(address addr) external returns (bytes32);
}


// File contracts/OperatorFilter/OperatorFilterer.sol


pragma solidity ^0.8.13;

abstract contract OperatorFilterer {
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry public constant operatorFilterRegistry =
        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);

    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(operatorFilterRegistry).code.length > 0) {
            if (subscribe) {
                operatorFilterRegistry.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    operatorFilterRegistry.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    operatorFilterRegistry.register(address(this));
                }
            }
        }
    }

    modifier onlyAllowedOperator(address from) virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(operatorFilterRegistry).code.length > 0) {
            // Allow spending tokens from addresses with balance
            // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
            // from an EOA.
            if (from == msg.sender) {
                _;
                return;
            }
            if (
                !(
                    operatorFilterRegistry.isOperatorAllowed(address(this), msg.sender)
                        && operatorFilterRegistry.isOperatorAllowed(address(this), from)
                )
            ) {
                revert OperatorNotAllowed(msg.sender);
            }
        }
        _;
    }
}


// File contracts/OperatorFilter/DefaultOperatorFilterer.sol


pragma solidity ^0.8.13;

abstract contract DefaultOperatorFilterer is OperatorFilterer {
    address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);

    constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}


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


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

pragma solidity ^0.8.0;

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


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


// OpenZeppelin Contracts (last updated v4.7.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 @openzeppelin/contracts/utils/[email protected]


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

pragma solidity ^0.8.0;

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

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


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


// OpenZeppelin Contracts (last updated v4.7.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
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


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


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

pragma solidity ^0.8.0;

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


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


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

pragma solidity ^0.8.0;

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

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

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


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


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

pragma solidity ^0.8.0;

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

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

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

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

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

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


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


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

pragma solidity ^0.8.0;

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


// File erc721a/contracts/[email protected]


// Creator: Chiru Labs

pragma solidity ^0.8.4;







error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();

/**
 * @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 Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Compiler will pack this into a single 256bit word.
    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;
    }

    // Compiler will pack this into a single 256bit word.
    struct AddressData {
        // Realistically, 2**64-1 is more than enough.
        uint64 balance;
        // Keeps track of mint count with minimal overhead for tokenomics.
        uint64 numberMinted;
        // Keeps track of burn count with minimal overhead for tokenomics.
        uint64 numberBurned;
        // For miscellaneous variable(s) pertaining to the address
        // (e.g. number of whitelist mint slots used).
        // If there are multiple variables, please pack them into a uint64.
        uint64 aux;
    }

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

    // The number of tokens burned.
    uint256 internal _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 _ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

    // Mapping owner address to address data
    mapping(address => AddressData) private _addressData;

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

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

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

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

    /**
     * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
     */
    function totalSupply() public view returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex - _startTokenId() times
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    /**
     * 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 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 override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return uint256(_addressData[owner].balance);
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberMinted);
    }

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

    /**
     * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        return _addressData[owner].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 {
        _addressData[owner].aux = aux;
    }

    /**
     * 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) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr && curr < _currentIndex) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (!ownership.burned) {
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                    // 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.
                    while (true) {
                        curr--;
                        ownership = _ownerships[curr];
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                    }
                }
            }
        }
        revert OwnerQueryForNonexistentToken();
    }

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

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

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

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

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

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

        _approve(to, tokenId, owner);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

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

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

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

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

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (to.isContract() && !_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 &&
            !_ownerships[tokenId].burned;
    }

    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        _mint(to, quantity, _data, true);
    }

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

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

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

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

            if (safe && to.isContract()) {
                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 Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) private {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();

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

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

        _beforeTokenTransfers(from, to, tokenId, 1);

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = to;
            currSlot.startTimestamp = uint64(block.timestamp);

            // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

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

    /**
     * @dev This is 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 {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        address from = prevOwnership.addr;

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

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

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

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            AddressData storage addressData = _addressData[from];
            addressData.balance -= 1;
            addressData.numberBurned += 1;

            // Keep track of who burned the token, and the timestamp of burning.
            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = from;
            currSlot.startTimestamp = uint64(block.timestamp);
            currSlot.burned = true;

            // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        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 Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(
        address to,
        uint256 tokenId,
        address owner
    ) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

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

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


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


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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


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


// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}


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


// OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol)

pragma solidity ^0.8.0;


/**
 * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
 * fee is specified in basis points by default.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC2981 is IERC2981, ERC165 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;

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

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: invalid receiver");

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: Invalid parameters");

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }
}


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


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

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

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

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

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

    /**
     * @dev Returns true if the `leaves` can be proved to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and the sibling nodes in `proof`,
     * consuming from one or the other at each step according to the instructions given by
     * `proofFlags`.
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

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

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

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

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

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

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

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

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

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


pragma solidity ^0.8.7;

error SaleInactive();
error SoldOut();
error InvalidPrice();
error WithdrawFailed();
error InvalidQuantity();
error InvalidProof();
error InvalidBatchMint();

contract Shimai is ERC721A, Ownable, ERC2981, OperatorFilterer {
    uint256 public price = 0.0049 ether;
    uint256 public maxPerWallet = 2;
    uint256 public maxPerTransaction = 1;
    uint256 public immutable supply = 888;
    string public _baseTokenURI = 'ipfs://QmP3Cbp6i7gTteE9HaU8kgXKziwdrQdri8m4bZiCrDTX7W/';

    enum SaleState {
        CLOSED,
        OPEN
    }
    SaleState public saleState = SaleState.CLOSED;
    mapping(address => uint256) public addressMintBalance;

    constructor() ERC721A("Shimai", "Shimai") OperatorFilterer(address(0), false) {
        _setDefaultRoyalty(0x1FEa77CEA66f10C3F877dB210967Df602faA2944, 0);
    }
////

    function mint(uint256 qty) external payable {
        if (saleState != SaleState.OPEN) revert SaleInactive();
        if (_currentIndex + (qty - 1) > supply) revert SoldOut();
        if (msg.value != price * qty) revert InvalidPrice();

        if (addressMintBalance[msg.sender] + qty > maxPerWallet) revert InvalidQuantity();
        if (qty > maxPerTransaction) revert InvalidQuantity();
        addressMintBalance[msg.sender] += qty;

        _safeMint(msg.sender, qty);

    }

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

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

    function setBaseURI(string memory baseURI) external onlyOwner {
        _baseTokenURI = baseURI;
    }

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

    function setSaleState(uint8 _state) external onlyOwner {
        saleState = SaleState(_state);
    }

    function freeMint(uint256 qty, address recipient) external onlyOwner {
        if (_currentIndex + (qty - 1) > supply) revert SoldOut();
        _safeMint(recipient, qty);
    }

    function batchMint(uint64[] calldata qtys, address[] calldata recipients)
        external
        onlyOwner
    {
        uint256 numRecipients = recipients.length;
        if (numRecipients != qtys.length) revert InvalidBatchMint();

        for (uint256 i = 0; i < numRecipients; ) {
            if ((_currentIndex - 1) + qtys[i] > supply) revert SoldOut();

            _safeMint(recipients[i], qtys[i]);

            unchecked {
                i++;
            }
        }
    }

    function setPerWalletMax(uint256 _val) external onlyOwner {
        maxPerWallet = _val;
    }

    function setPerTransactionMax(uint256 _val) external onlyOwner {
        maxPerTransaction = _val;
    }

    function withdraw() external onlyOwner {
        (bool success, ) = payable(owner()).call{value: address(this).balance}("");
        if (!success) revert WithdrawFailed();
    }

    function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
        external
        onlyOwner
    {
        _setDefaultRoyalty(receiver, feeBasisPoints);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721A, ERC2981)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }

    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public override onlyAllowedOperator(from) {
        super.transferFrom(from, to, tokenId);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public override onlyAllowedOperator(from) {
        super.safeTransferFrom(from, to, tokenId);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) public override onlyAllowedOperator(from) {
        super.safeTransferFrom(from, to, tokenId, data);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"InvalidBatchMint","type":"error"},{"inputs":[],"name":"InvalidPrice","type":"error"},{"inputs":[],"name":"InvalidQuantity","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"SaleInactive","type":"error"},{"inputs":[],"name":"SoldOut","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"},{"inputs":[],"name":"WithdrawFailed","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":[],"name":"_baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"addressMintBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint64[]","name":"qtys","type":"uint64[]"},{"internalType":"address[]","name":"recipients","type":"address[]"}],"name":"batchMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"qty","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"name":"freeMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPerTransaction","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"qty","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operatorFilterRegistry","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"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":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"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":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleState","outputs":[{"internalType":"enum Shimai.SaleState","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_val","type":"uint256"}],"name":"setPerTransactionMax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_val","type":"uint256"}],"name":"setPerWalletMax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint96","name":"feeBasisPoints","type":"uint96"}],"name":"setRoyaltyInfo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"_state","type":"uint8"}],"name":"setSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"supply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

64146:3887:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67161:204;;;;;;;;;;-1:-1:-1;67161:204:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;67161:204:0;;;;;;;;66983:170;;;;;;;;;;-1:-1:-1;66983:170:0;;;;;:::i;:::-;;:::i;:::-;;64339:37;;;;;;;;;;;;;;;;;;1287:25:1;;;1275:2;1260:18;64339:37:0;1141:177:1;32794:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;34306:204::-;;;;;;;;;;-1:-1:-1;34306:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2423:32:1;;;2405:51;;2393:2;2378:18;34306:204:0;2259:203:1;33869:371:0;;;;;;;;;;-1:-1:-1;33869:371:0;;;;;:::i;:::-;;:::i;28930:303::-;;;;;;;;;;-1:-1:-1;65421:1:0;29184:12;28974:7;29168:13;:28;-1:-1:-1;;29168:46:0;28930:303;;67373:197;;;;;;;;;;-1:-1:-1;67373:197:0;;;;;:::i;:::-;;:::i;52720:442::-;;;;;;;;;;-1:-1:-1;52720:442:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;3504:32:1;;;3486:51;;3568:2;3553:18;;3546:34;;;;3459:18;52720:442:0;3312:274:1;64590:53:0;;;;;;;;;;-1:-1:-1;64590:53:0;;;;;:::i;:::-;;;;;;;;;;;;;;65881:180;;;;;;;;;;-1:-1:-1;65881:180:0;;;;;:::i;:::-;;:::i;66577:96::-;;;;;;;;;;-1:-1:-1;66577:96:0;;;;;:::i;:::-;;:::i;66795:180::-;;;;;;;;;;;;;:::i;67578:205::-;;;;;;;;;;-1:-1:-1;67578:205:0;;;;;:::i;:::-;;:::i;64258:31::-;;;;;;;;;;;;;;;;64296:36;;;;;;;;;;;;;;;;65560:104;;;;;;;;;;-1:-1:-1;65560:104:0;;;;;:::i;:::-;;:::i;65770:103::-;;;;;;;;;;-1:-1:-1;65770:103:0;;;;;:::i;:::-;;:::i;64538:45::-;;;;;;;;;;-1:-1:-1;64538:45:0;;;;;;;;;;;;;;;:::i;32602:125::-;;;;;;;;;;-1:-1:-1;32602:125:0;;;;;:::i;:::-;;:::i;66069:500::-;;;;;;;;;;-1:-1:-1;66069:500:0;;;;;:::i;:::-;;:::i;30050:206::-;;;;;;;;;;-1:-1:-1;30050:206:0;;;;;:::i;:::-;;:::i;49337:103::-;;;;;;;;;;;;;:::i;48689:87::-;;;;;;;;;;-1:-1:-1;48762:6:0;;-1:-1:-1;;;;;48762:6:0;48689:87;;65672:90;;;;;;;;;;-1:-1:-1;65672:90:0;;;;;:::i;:::-;;:::i;32963:104::-;;;;;;;;;;;;;:::i;64216:35::-;;;;;;;;;;;;;;;;64828:493;;;;;;:::i;:::-;;:::i;34582:287::-;;;;;;;;;;-1:-1:-1;34582:287:0;;;;;:::i;:::-;;:::i;2425:141::-;;;;;;;;;;;;2523:42;2425:141;;67791:239;;;;;;;;;;-1:-1:-1;67791:239:0;;;;;:::i;:::-;;:::i;66681:106::-;;;;;;;;;;-1:-1:-1;66681:106:0;;;;;:::i;:::-;;:::i;33138:327::-;;;;;;;;;;-1:-1:-1;33138:327:0;;;;;:::i;:::-;;:::i;64383:86::-;;;;;;;;;;;;;:::i;34940:164::-;;;;;;;;;;-1:-1:-1;34940:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;35061:25:0;;;35037:4;35061:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;34940:164;49595:201;;;;;;;;;;-1:-1:-1;49595:201:0;;;;;:::i;:::-;;:::i;67161:204::-;67292:4;67321:36;67345:11;67321:23;:36::i;:::-;67314:43;67161:204;-1:-1:-1;;67161:204:0:o;66983:170::-;48575:13;:11;:13::i;:::-;67101:44:::1;67120:8;67130:14;67101:18;:44::i;:::-;66983:170:::0;;:::o;32794:100::-;32848:13;32881:5;32874:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32794:100;:::o;34306:204::-;34374:7;34399:16;34407:7;34399;:16::i;:::-;34394:64;;34424:34;;-1:-1:-1;;;34424:34:0;;;;;;;;;;;34394:64;-1:-1:-1;34478:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;34478:24:0;;34306:204::o;33869:371::-;33942:13;33958:24;33974:7;33958:15;:24::i;:::-;33942:40;;34003:5;-1:-1:-1;;;;;33997:11:0;:2;-1:-1:-1;;;;;33997:11:0;;33993:48;;34017:24;;-1:-1:-1;;;34017:24:0;;;;;;;;;;;33993:48;11289:10;-1:-1:-1;;;;;34058:21:0;;;;;;:63;;-1:-1:-1;34084:37:0;34101:5;11289:10;34940:164;:::i;34084:37::-;34083:38;34058:63;34054:138;;;34145:35;;-1:-1:-1;;;34145:35:0;;;;;;;;;;;34054:138;34204:28;34213:2;34217:7;34226:5;34204:8;:28::i;:::-;33931:309;33869:371;;:::o;67373:197::-;67508:4;2523:42;3663:43;:47;3659:699;;3950:10;-1:-1:-1;;;;;3942:18:0;;;3938:85;;67525:37:::1;67544:4;67550:2;67554:7;67525:18;:37::i;:::-;4001:7:::0;;3938:85;4083:67;;-1:-1:-1;;;4083:67:0;;4132:4;4083:67;;;9381:34:1;4139:10:0;9431:18:1;;;9424:43;2523:42:0;;4083:40;;9316:18:1;;4083:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:157;;;;-1:-1:-1;4179:61:0;;-1:-1:-1;;;4179:61:0;;4228:4;4179:61;;;9381:34:1;-1:-1:-1;;;;;9451:15:1;;9431:18;;;9424:43;2523:42:0;;4179:40;;9316:18:1;;4179:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4037:310;;4301:30;;-1:-1:-1;;;4301:30:0;;4320:10;4301:30;;;2405:51:1;2378:18;;4301:30:0;;;;;;;;4037:310;67525:37:::1;67544:4;67550:2;67554:7;67525:18;:37::i;:::-;67373:197:::0;;;;:::o;52720:442::-;52817:7;52875:27;;;:17;:27;;;;;;;;52846:56;;;;;;;;;-1:-1:-1;;;;;52846:56:0;;;;;-1:-1:-1;;;52846:56:0;;;-1:-1:-1;;;;;52846:56:0;;;;;;;;52817:7;;52915:92;;-1:-1:-1;52966:29:0;;;;;;;;;52976:19;52966:29;-1:-1:-1;;;;;52966:29:0;;;;-1:-1:-1;;;52966:29:0;;-1:-1:-1;;;;;52966:29:0;;;;;52915:92;53057:23;;;;53019:21;;53528:5;;53044:36;;-1:-1:-1;;;;;53044:36:0;:10;:36;:::i;:::-;53043:58;;;;:::i;:::-;53122:16;;;-1:-1:-1;53019:82:0;;-1:-1:-1;;52720:442:0;;;;;;:::o;65881:180::-;48575:13;:11;:13::i;:::-;65993:6:::1;65982:7;65988:1;65982:3:::0;:7:::1;:::i;:::-;65965:13;;:25;;;;:::i;:::-;:34;65961:56;;;66008:9;;-1:-1:-1::0;;;66008:9:0::1;;;;;;;;;;;65961:56;66028:25;66038:9;66049:3;66028:9;:25::i;66577:96::-:0;48575:13;:11;:13::i;:::-;66646:12:::1;:19:::0;66577:96::o;66795:180::-;48575:13;:11;:13::i;:::-;66846:12:::1;66872:7;48762:6:::0;;-1:-1:-1;;;;;48762:6:0;;48689:87;66872:7:::1;-1:-1:-1::0;;;;;66864:21:0::1;66893;66864:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66845:74;;;66935:7;66930:37;;66951:16;;-1:-1:-1::0;;;66951:16:0::1;;;;;;;;;;;66930:37;66834:141;66795:180::o:0;67578:205::-;67717:4;2523:42;3663:43;:47;3659:699;;3950:10;-1:-1:-1;;;;;3942:18:0;;;3938:85;;67734:41:::1;67757:4;67763:2;67767:7;67734:22;:41::i;3938:85::-:0;4083:67;;-1:-1:-1;;;4083:67:0;;4132:4;4083:67;;;9381:34:1;4139:10:0;9431:18:1;;;9424:43;2523:42:0;;4083:40;;9316:18:1;;4083:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:157;;;;-1:-1:-1;4179:61:0;;-1:-1:-1;;;4179:61:0;;4228:4;4179:61;;;9381:34:1;-1:-1:-1;;;;;9451:15:1;;9431:18;;;9424:43;2523:42:0;;4179:40;;9316:18:1;;4179:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4037:310;;4301:30;;-1:-1:-1;;;4301:30:0;;4320:10;4301:30;;;2405:51:1;2378:18;;4301:30:0;2259:203:1;4037:310:0;67734:41:::1;67757:4;67763:2;67767:7;67734:22;:41::i;65560:104::-:0;48575:13;:11;:13::i;:::-;65633:23;;::::1;::::0;:13:::1;::::0;:23:::1;::::0;::::1;::::0;::::1;:::i;65770:103::-:0;48575:13;:11;:13::i;:::-;65858:6:::1;65848:17;;;;;;;;;;:::i;:::-;65836:9;:29:::0;;-1:-1:-1;;65836:29:0::1;::::0;;;;::::1;;;;;;:::i;:::-;;;;;;65770:103:::0;:::o;32602:125::-;32666:7;32693:21;32706:7;32693:12;:21::i;:::-;:26;;32602:125;-1:-1:-1;;32602:125:0:o;66069:500::-;48575:13;:11;:13::i;:::-;66220:10;66252:28;;::::1;66248:59;;66289:18;;-1:-1:-1::0;;;66289:18:0::1;;;;;;;;;;;66248:59;66325:9;66320:242;66344:13;66340:1;:17;66320:242;;;66412:6;66402:4;;66407:1;66402:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;66380:29:0::1;66397:1;66381:13;;:17;;;;:::i;:::-;66380:29;;;;:::i;:::-;:38;66376:60;;;66427:9;;-1:-1:-1::0;;;66427:9:0::1;;;;;;;;;;;66376:60;66453:33;66463:10;;66474:1;66463:13;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;66478:4;;66483:1;66478:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;66453:33:0::1;:9;:33::i;:::-;66532:3;;66320:242;;;;66185:384;66069:500:::0;;;;:::o;30050:206::-;30114:7;-1:-1:-1;;;;;30138:19:0;;30134:60;;30166:28;;-1:-1:-1;;;30166:28:0;;;;;;;;;;;30134:60;-1:-1:-1;;;;;;30220:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;30220:27:0;;30050:206::o;49337:103::-;48575:13;:11;:13::i;:::-;49402:30:::1;49429:1;49402:18;:30::i;:::-;49337:103::o:0;65672:90::-;48575:13;:11;:13::i;:::-;65738:5:::1;:16:::0;65672:90::o;32963:104::-;33019:13;33052:7;33045:14;;;;;:::i;64828:493::-;64900:14;64887:9;;;;;:27;;;;;;;:::i;:::-;;64883:54;;64923:14;;-1:-1:-1;;;64923:14:0;;;;;;;;;;;64883:54;64980:6;64969:7;64975:1;64969:3;:7;:::i;:::-;64952:13;;:25;;;;:::i;:::-;:34;64948:56;;;64995:9;;-1:-1:-1;;;64995:9:0;;;;;;;;;;;64948:56;65040:3;65032:5;;:11;;;;:::i;:::-;65019:9;:24;65015:51;;65052:14;;-1:-1:-1;;;65052:14:0;;;;;;;;;;;65015:51;65122:12;;65102:10;65083:30;;;;:18;:30;;;;;;:36;;65116:3;;65083:36;:::i;:::-;:51;65079:81;;;65143:17;;-1:-1:-1;;;65143:17:0;;;;;;;;;;;65079:81;65181:17;;65175:3;:23;65171:53;;;65207:17;;-1:-1:-1;;;65207:17:0;;;;;;;;;;;65171:53;65254:10;65235:30;;;;:18;:30;;;;;:37;;65269:3;;65235:30;:37;;65269:3;;65235:37;:::i;:::-;;;;-1:-1:-1;65285:26:0;;-1:-1:-1;65295:10:0;65307:3;65285:9;:26::i;34582:287::-;11289:10;-1:-1:-1;;;;;34681:24:0;;;34677:54;;34714:17;;-1:-1:-1;;;34714:17:0;;;;;;;;;;;34677:54;11289:10;34744:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;34744:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;34744:53:0;;;;;;;;;;34813:48;;540:41:1;;;34744:42:0;;11289:10;34813:48;;513:18:1;34813:48:0;;;;;;;34582:287;;:::o;67791:239::-;67958:4;2523:42;3663:43;:47;3659:699;;3950:10;-1:-1:-1;;;;;3942:18:0;;;3938:85;;67975:47:::1;67998:4;68004:2;68008:7;68017:4;67975:22;:47::i;:::-;4001:7:::0;;3938:85;4083:67;;-1:-1:-1;;;4083:67:0;;4132:4;4083:67;;;9381:34:1;4139:10:0;9431:18:1;;;9424:43;2523:42:0;;4083:40;;9316:18:1;;4083:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:157;;;;-1:-1:-1;4179:61:0;;-1:-1:-1;;;4179:61:0;;4228:4;4179:61;;;9381:34:1;-1:-1:-1;;;;;9451:15:1;;9431:18;;;9424:43;2523:42:0;;4179:40;;9316:18:1;;4179:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4037:310;;4301:30;;-1:-1:-1;;;4301:30:0;;4320:10;4301:30;;;2405:51:1;2378:18;;4301:30:0;2259:203:1;4037:310:0;67975:47:::1;67998:4;68004:2;68008:7;68017:4;67975:22;:47::i;:::-;67791:239:::0;;;;;:::o;66681:106::-;48575:13;:11;:13::i;:::-;66755:17:::1;:24:::0;66681:106::o;33138:327::-;33211:13;33242:16;33250:7;33242;:16::i;:::-;33237:59;;33267:29;;-1:-1:-1;;;33267:29:0;;;;;;;;;;;33237:59;33309:21;33333:10;:8;:10::i;:::-;33309:34;;33367:7;33361:21;33386:1;33361:26;:96;;;;;;;;;;;;;;;;;33414:7;33423:18;:7;:16;:18::i;:::-;33397:54;;;;;;;;;:::i;:::-;;;;;;;;;;;;;33361:96;33354:103;33138:327;-1:-1:-1;;;33138:327:0:o;64383:86::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;49595:201::-;48575:13;:11;:13::i;:::-;-1:-1:-1;;;;;49684:22:0;::::1;49676:73;;;::::0;-1:-1:-1;;;49676:73:0;;12028:2:1;49676:73:0::1;::::0;::::1;12010:21:1::0;12067:2;12047:18;;;12040:30;12106:34;12086:18;;;12079:62;-1:-1:-1;;;12157:18:1;;;12150:36;12203:19;;49676:73:0::1;11826:402:1::0;49676:73:0::1;49760:28;49779:8;49760:18;:28::i;52450:215::-:0;52552:4;-1:-1:-1;;;;;;52576:41:0;;-1:-1:-1;;;52576:41:0;;:81;;;52621:36;52645:11;52621:23;:36::i;48854:132::-;48762:6;;-1:-1:-1;;;;;48762:6:0;11289:10;48918:23;48910:68;;;;-1:-1:-1;;;48910:68:0;;12435:2:1;48910:68:0;;;12417:21:1;;;12454:18;;;12447:30;12513:34;12493:18;;;12486:62;12565:18;;48910:68:0;12233:356:1;53812:332:0;53528:5;-1:-1:-1;;;;;53915:33:0;;;;53907:88;;;;-1:-1:-1;;;53907:88:0;;12796:2:1;53907:88:0;;;12778:21:1;12835:2;12815:18;;;12808:30;12874:34;12854:18;;;12847:62;-1:-1:-1;;;12925:18:1;;;12918:40;12975:19;;53907:88:0;12594:406:1;53907:88:0;-1:-1:-1;;;;;54014:22:0;;54006:60;;;;-1:-1:-1;;;54006:60:0;;13207:2:1;54006:60:0;;;13189:21:1;13246:2;13226:18;;;13219:30;13285:27;13265:18;;;13258:55;13330:18;;54006:60:0;13005:349:1;54006:60:0;54101:35;;;;;;;;;-1:-1:-1;;;;;54101:35:0;;;;;;-1:-1:-1;;;;;54101:35:0;;;;;;;;;;-1:-1:-1;;;54079:57:0;;;;:19;:57;53812:332::o;36292:187::-;36349:4;36392:7;65421:1;36373:26;;:53;;;;;36413:13;;36403:7;:23;36373:53;:98;;;;-1:-1:-1;;36444:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;36444:27:0;;;;36443:28;;36292:187::o;44462:196::-;44577:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;44577:29:0;-1:-1:-1;;;;;44577:29:0;;;;;;;;;44622:28;;44577:24;;44622:28;;;;;;;44462:196;;;:::o;35171:170::-;35305:28;35315:4;35321:2;35325:7;35305:9;:28::i;36487:104::-;36556:27;36566:2;36570:8;36556:27;;;;;;;;;;;;:9;:27::i;35412:185::-;35550:39;35567:4;35573:2;35577:7;35550:39;;;;;;;;;;;;:16;:39::i;31431:1109::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;31542:7:0;;65421:1;31591:23;;:47;;;;;31625:13;;31618:4;:20;31591:47;31587:886;;;31659:31;31693:17;;;:11;:17;;;;;;;;;31659:51;;;;;;;;;-1:-1:-1;;;;;31659:51:0;;;;-1:-1:-1;;;31659:51:0;;-1:-1:-1;;;;;31659:51:0;;;;;;;;-1:-1:-1;;;31659:51:0;;;;;;;;;;;;;;31729:729;;31779:14;;-1:-1:-1;;;;;31779:28:0;;31775:101;;31843:9;31431:1109;-1:-1:-1;;;31431:1109:0:o;31775:101::-;-1:-1:-1;;;32218:6:0;32263:17;;;;:11;:17;;;;;;;;;32251:29;;;;;;;;;-1:-1:-1;;;;;32251:29:0;;;;;-1:-1:-1;;;32251:29:0;;-1:-1:-1;;;;;32251:29:0;;;;;;;;-1:-1:-1;;;32251:29:0;;;;;;;;;;;;;32311:28;32307:109;;32379:9;31431:1109;-1:-1:-1;;;31431:1109:0:o;32307:109::-;32178:261;;;31640:833;31587:886;32501:31;;-1:-1:-1;;;32501:31:0;;;;;;;;;;;49956:191;50049:6;;;-1:-1:-1;;;;;50066:17:0;;;-1:-1:-1;;;;;;50066:17:0;;;;;;;50099:40;;50049:6;;;50066:17;50049:6;;50099:40;;50030:16;;50099:40;50019:128;49956:191;:::o;35668:369::-;35835:28;35845:4;35851:2;35855:7;35835:9;:28::i;:::-;-1:-1:-1;;;;;35878:13:0;;12959:19;:23;;35878:76;;;;;35898:56;35929:4;35935:2;35939:7;35948:5;35898:30;:56::i;:::-;35897:57;35878:76;35874:156;;;35978:40;;-1:-1:-1;;;35978:40:0;;;;;;;;;;;65438:114;65498:13;65531;65524:20;;;;;:::i;22303:723::-;22359:13;22580:5;22589:1;22580:10;22576:53;;-1:-1:-1;;22607:10:0;;;;;;;;;;;;-1:-1:-1;;;22607:10:0;;;;;22303:723::o;22576:53::-;22654:5;22639:12;22695:78;22702:9;;22695:78;;22728:8;;;;:::i;:::-;;-1:-1:-1;22751:10:0;;-1:-1:-1;22759:2:0;22751:10;;:::i;:::-;;;22695:78;;;22783:19;22815:6;-1:-1:-1;;;;;22805:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;22805:17:0;;22783:39;;22833:154;22840:10;;22833:154;;22867:11;22877:1;22867:11;;:::i;:::-;;-1:-1:-1;22936:10:0;22944:2;22936:5;:10;:::i;:::-;22923:24;;:2;:24;:::i;:::-;22910:39;;22893:6;22900;22893:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;22893:56:0;;;;;;;;-1:-1:-1;22964:11:0;22973:2;22964:11;;:::i;:::-;;;22833:154;;;23011:6;22303:723;-1:-1:-1;;;;22303:723:0:o;29681:305::-;29783:4;-1:-1:-1;;;;;;29820:40:0;;-1:-1:-1;;;29820:40:0;;:105;;-1:-1:-1;;;;;;;29877:48:0;;-1:-1:-1;;;29877:48:0;29820:105;:158;;;-1:-1:-1;;;;;;;;;;25350:40:0;;;29942:36;25241:157;39405:2130;39520:35;39558:21;39571:7;39558:12;:21::i;:::-;39520:59;;39618:4;-1:-1:-1;;;;;39596:26:0;:13;:18;;;-1:-1:-1;;;;;39596:26:0;;39592:67;;39631:28;;-1:-1:-1;;;39631:28:0;;;;;;;;;;;39592:67;39672:22;11289:10;-1:-1:-1;;;;;39698:20:0;;;;:73;;-1:-1:-1;39735:36:0;39752:4;11289:10;34940:164;:::i;39735:36::-;39698:126;;;-1:-1:-1;11289:10:0;39788:20;39800:7;39788:11;:20::i;:::-;-1:-1:-1;;;;;39788:36:0;;39698:126;39672:153;;39843:17;39838:66;;39869:35;;-1:-1:-1;;;39869:35:0;;;;;;;;;;;39838:66;-1:-1:-1;;;;;39919:16:0;;39915:52;;39944:23;;-1:-1:-1;;;39944:23:0;;;;;;;;;;;39915:52;40088:35;40105:1;40109:7;40118:4;40088:8;:35::i;:::-;-1:-1:-1;;;;;40419:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;40419:31:0;;;-1:-1:-1;;;;;40419:31:0;;;-1:-1:-1;;40419:31:0;;;;;;;40465:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;40465:29:0;;;;;;;;;;;40545:20;;;:11;:20;;;;;;40580:18;;-1:-1:-1;;;;;;40613:49:0;;;;-1:-1:-1;;;40646:15:0;40613:49;;;;;;;;;;40936:11;;40996:24;;;;;41039:13;;40545:20;;40996:24;;41039:13;41035:384;;41249:13;;41234:11;:28;41230:174;;41287:20;;41356:28;;;;-1:-1:-1;;;;;41330:54:0;-1:-1:-1;;;41330:54:0;-1:-1:-1;;;;;;41330:54:0;;;-1:-1:-1;;;;;41287:20:0;;41330:54;;;;41230:174;40394:1036;;;41466:7;41462:2;-1:-1:-1;;;;;41447:27:0;41456:4;-1:-1:-1;;;;;41447:27:0;;;;;;;;;;;41485:42;67373:197;36954:163;37077:32;37083:2;37087:8;37097:5;37104:4;37077:5;:32::i;45150:667::-;45334:72;;-1:-1:-1;;;45334:72:0;;45313:4;;-1:-1:-1;;;;;45334:36:0;;;;;:72;;11289:10;;45385:4;;45391:7;;45400:5;;45334:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45334:72:0;;;;;;;;-1:-1:-1;;45334:72:0;;;;;;;;;;;;:::i;:::-;;;45330:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45568:6;:13;45585:1;45568:18;45564:235;;45614:40;;-1:-1:-1;;;45614:40:0;;;;;;;;;;;45564:235;45757:6;45751:13;45742:6;45738:2;45734:15;45727:38;45330:480;-1:-1:-1;;;;;;45453:55:0;-1:-1:-1;;;45453:55:0;;-1:-1:-1;45150:667:0;;;;;;:::o;37376:1775::-;37515:20;37538:13;-1:-1:-1;;;;;37566:16:0;;37562:48;;37591:19;;-1:-1:-1;;;37591:19:0;;;;;;;;;;;37562:48;37625:8;37637:1;37625:13;37621:44;;37647:18;;-1:-1:-1;;;37647:18:0;;;;;;;;;;;37621:44;-1:-1:-1;;;;;38016:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;38075:49:0;;-1:-1:-1;;;;;38016:44:0;;;;;;;38075:49;;;;-1:-1:-1;;38016:44:0;;;;;;38075:49;;;;;;;;;;;;;;;;38141:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;38191:66:0;;;;-1:-1:-1;;;38241:15:0;38191:66;;;;;;;;;;38141:25;38338:23;;;38382:4;:23;;;;-1:-1:-1;;;;;;38390:13:0;;12959:19;:23;;38390:15;38378:641;;;38426:314;38457:38;;38482:12;;-1:-1:-1;;;;;38457:38:0;;;38474:1;;38457:38;;38474:1;;38457:38;38523:69;38562:1;38566:2;38570:14;;;;;;38586:5;38523:30;:69::i;:::-;38518:174;;38628:40;;-1:-1:-1;;;38628:40:0;;;;;;;;;;;38518:174;38735:3;38719:12;:19;38426:314;;38821:12;38804:13;;:29;38800:43;;38835:8;;;38800:43;38378:641;;;38884:120;38915:40;;38940:14;;;;;-1:-1:-1;;;;;38915:40:0;;;38932:1;;38915:40;;38932:1;;38915:40;38999:3;38983:12;:19;38884:120;;38378:641;-1:-1:-1;39033:13:0;:28;39083:60;67373:197;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:173::-;660:20;;-1:-1:-1;;;;;709:31:1;;699:42;;689:70;;755:1;752;745:12;689:70;592:173;;;:::o;770:366::-;837:6;845;898:2;886:9;877:7;873:23;869:32;866:52;;;914:1;911;904:12;866:52;937:29;956:9;937:29;:::i;:::-;927:39;;1016:2;1005:9;1001:18;988:32;-1:-1:-1;;;;;1053:5:1;1049:38;1042:5;1039:49;1029:77;;1102:1;1099;1092:12;1029:77;1125:5;1115:15;;;770:366;;;;;:::o;1323:258::-;1395:1;1405:113;1419:6;1416:1;1413:13;1405:113;;;1495:11;;;1489:18;1476:11;;;1469:39;1441:2;1434:10;1405:113;;;1536:6;1533:1;1530:13;1527:48;;;-1:-1:-1;;1571:1:1;1553:16;;1546:27;1323:258::o;1586:::-;1628:3;1666:5;1660:12;1693:6;1688:3;1681:19;1709:63;1765:6;1758:4;1753:3;1749:14;1742:4;1735:5;1731:16;1709:63;:::i;:::-;1826:2;1805:15;-1:-1:-1;;1801:29:1;1792:39;;;;1833:4;1788:50;;1586:258;-1:-1:-1;;1586:258:1:o;1849:220::-;1998:2;1987:9;1980:21;1961:4;2018:45;2059:2;2048:9;2044:18;2036:6;2018:45;:::i;2074:180::-;2133:6;2186:2;2174:9;2165:7;2161:23;2157:32;2154:52;;;2202:1;2199;2192:12;2154:52;-1:-1:-1;2225:23:1;;2074:180;-1:-1:-1;2074:180:1:o;2467:254::-;2535:6;2543;2596:2;2584:9;2575:7;2571:23;2567:32;2564:52;;;2612:1;2609;2602:12;2564:52;2635:29;2654:9;2635:29;:::i;:::-;2625:39;2711:2;2696:18;;;;2683:32;;-1:-1:-1;;;2467:254:1:o;2726:328::-;2803:6;2811;2819;2872:2;2860:9;2851:7;2847:23;2843:32;2840:52;;;2888:1;2885;2878:12;2840:52;2911:29;2930:9;2911:29;:::i;:::-;2901:39;;2959:38;2993:2;2982:9;2978:18;2959:38;:::i;:::-;2949:48;;3044:2;3033:9;3029:18;3016:32;3006:42;;2726:328;;;;;:::o;3059:248::-;3127:6;3135;3188:2;3176:9;3167:7;3163:23;3159:32;3156:52;;;3204:1;3201;3194:12;3156:52;-1:-1:-1;;3227:23:1;;;3297:2;3282:18;;;3269:32;;-1:-1:-1;3059:248:1:o;3591:186::-;3650:6;3703:2;3691:9;3682:7;3678:23;3674:32;3671:52;;;3719:1;3716;3709:12;3671:52;3742:29;3761:9;3742:29;:::i;3782:254::-;3850:6;3858;3911:2;3899:9;3890:7;3886:23;3882:32;3879:52;;;3927:1;3924;3917:12;3879:52;3963:9;3950:23;3940:33;;3992:38;4026:2;4015:9;4011:18;3992:38;:::i;:::-;3982:48;;3782:254;;;;;:::o;4041:127::-;4102:10;4097:3;4093:20;4090:1;4083:31;4133:4;4130:1;4123:15;4157:4;4154:1;4147:15;4173:632;4238:5;-1:-1:-1;;;;;4309:2:1;4301:6;4298:14;4295:40;;;4315:18;;:::i;:::-;4390:2;4384:9;4358:2;4444:15;;-1:-1:-1;;4440:24:1;;;4466:2;4436:33;4432:42;4420:55;;;4490:18;;;4510:22;;;4487:46;4484:72;;;4536:18;;:::i;:::-;4576:10;4572:2;4565:22;4605:6;4596:15;;4635:6;4627;4620:22;4675:3;4666:6;4661:3;4657:16;4654:25;4651:45;;;4692:1;4689;4682:12;4651:45;4742:6;4737:3;4730:4;4722:6;4718:17;4705:44;4797:1;4790:4;4781:6;4773;4769:19;4765:30;4758:41;;;;4173:632;;;;;:::o;4810:451::-;4879:6;4932:2;4920:9;4911:7;4907:23;4903:32;4900:52;;;4948:1;4945;4938:12;4900:52;4988:9;4975:23;-1:-1:-1;;;;;5013:6:1;5010:30;5007:50;;;5053:1;5050;5043:12;5007:50;5076:22;;5129:4;5121:13;;5117:27;-1:-1:-1;5107:55:1;;5158:1;5155;5148:12;5107:55;5181:74;5247:7;5242:2;5229:16;5224:2;5220;5216:11;5181:74;:::i;5266:269::-;5323:6;5376:2;5364:9;5355:7;5351:23;5347:32;5344:52;;;5392:1;5389;5382:12;5344:52;5431:9;5418:23;5481:4;5474:5;5470:16;5463:5;5460:27;5450:55;;5501:1;5498;5491:12;5540:127;5601:10;5596:3;5592:20;5589:1;5582:31;5632:4;5629:1;5622:15;5656:4;5653:1;5646:15;5672:342;5818:2;5803:18;;5851:1;5840:13;;5830:144;;5896:10;5891:3;5887:20;5884:1;5877:31;5931:4;5928:1;5921:15;5959:4;5956:1;5949:15;5830:144;5983:25;;;5672:342;:::o;6019:366::-;6081:8;6091:6;6145:3;6138:4;6130:6;6126:17;6122:27;6112:55;;6163:1;6160;6153:12;6112:55;-1:-1:-1;6186:20:1;;-1:-1:-1;;;;;6218:30:1;;6215:50;;;6261:1;6258;6251:12;6215:50;6298:4;6290:6;6286:17;6274:29;;6358:3;6351:4;6341:6;6338:1;6334:14;6326:6;6322:27;6318:38;6315:47;6312:67;;;6375:1;6372;6365:12;6390:770;6511:6;6519;6527;6535;6588:2;6576:9;6567:7;6563:23;6559:32;6556:52;;;6604:1;6601;6594:12;6556:52;6644:9;6631:23;-1:-1:-1;;;;;6714:2:1;6706:6;6703:14;6700:34;;;6730:1;6727;6720:12;6700:34;6769:69;6830:7;6821:6;6810:9;6806:22;6769:69;:::i;:::-;6857:8;;-1:-1:-1;6743:95:1;-1:-1:-1;6945:2:1;6930:18;;6917:32;;-1:-1:-1;6961:16:1;;;6958:36;;;6990:1;6987;6980:12;6958:36;;7029:71;7092:7;7081:8;7070:9;7066:24;7029:71;:::i;:::-;6390:770;;;;-1:-1:-1;7119:8:1;-1:-1:-1;;;;6390:770:1:o;7165:118::-;7251:5;7244:13;7237:21;7230:5;7227:32;7217:60;;7273:1;7270;7263:12;7288:315;7353:6;7361;7414:2;7402:9;7393:7;7389:23;7385:32;7382:52;;;7430:1;7427;7420:12;7382:52;7453:29;7472:9;7453:29;:::i;:::-;7443:39;;7532:2;7521:9;7517:18;7504:32;7545:28;7567:5;7545:28;:::i;7847:667::-;7942:6;7950;7958;7966;8019:3;8007:9;7998:7;7994:23;7990:33;7987:53;;;8036:1;8033;8026:12;7987:53;8059:29;8078:9;8059:29;:::i;:::-;8049:39;;8107:38;8141:2;8130:9;8126:18;8107:38;:::i;:::-;8097:48;;8192:2;8181:9;8177:18;8164:32;8154:42;;8247:2;8236:9;8232:18;8219:32;-1:-1:-1;;;;;8266:6:1;8263:30;8260:50;;;8306:1;8303;8296:12;8260:50;8329:22;;8382:4;8374:13;;8370:27;-1:-1:-1;8360:55:1;;8411:1;8408;8401:12;8360:55;8434:74;8500:7;8495:2;8482:16;8477:2;8473;8469:11;8434:74;:::i;:::-;8424:84;;;7847:667;;;;;;;:::o;8519:260::-;8587:6;8595;8648:2;8636:9;8627:7;8623:23;8619:32;8616:52;;;8664:1;8661;8654:12;8616:52;8687:29;8706:9;8687:29;:::i;:::-;8677:39;;8735:38;8769:2;8758:9;8754:18;8735:38;:::i;8784:380::-;8863:1;8859:12;;;;8906;;;8927:61;;8981:4;8973:6;8969:17;8959:27;;8927:61;9034:2;9026:6;9023:14;9003:18;9000:38;8997:161;;9080:10;9075:3;9071:20;9068:1;9061:31;9115:4;9112:1;9105:15;9143:4;9140:1;9133:15;8997:161;;8784:380;;;:::o;9478:245::-;9545:6;9598:2;9586:9;9577:7;9573:23;9569:32;9566:52;;;9614:1;9611;9604:12;9566:52;9646:9;9640:16;9665:28;9687:5;9665:28;:::i;9728:127::-;9789:10;9784:3;9780:20;9777:1;9770:31;9820:4;9817:1;9810:15;9844:4;9841:1;9834:15;9860:168;9900:7;9966:1;9962;9958:6;9954:14;9951:1;9948:21;9943:1;9936:9;9929:17;9925:45;9922:71;;;9973:18;;:::i;:::-;-1:-1:-1;10013:9:1;;9860:168::o;10033:127::-;10094:10;10089:3;10085:20;10082:1;10075:31;10125:4;10122:1;10115:15;10149:4;10146:1;10139:15;10165:120;10205:1;10231;10221:35;;10236:18;;:::i;:::-;-1:-1:-1;10270:9:1;;10165:120::o;10290:125::-;10330:4;10358:1;10355;10352:8;10349:34;;;10363:18;;:::i;:::-;-1:-1:-1;10400:9:1;;10290:125::o;10420:128::-;10460:3;10491:1;10487:6;10484:1;10481:13;10478:39;;;10497:18;;:::i;:::-;-1:-1:-1;10533:9:1;;10420:128::o;10763:127::-;10824:10;10819:3;10815:20;10812:1;10805:31;10855:4;10852:1;10845:15;10879:4;10876:1;10869:15;10895:284;10953:6;11006:2;10994:9;10985:7;10981:23;10977:32;10974:52;;;11022:1;11019;11012:12;10974:52;11061:9;11048:23;-1:-1:-1;;;;;11104:5:1;11100:30;11093:5;11090:41;11080:69;;11145:1;11142;11135:12;11184:637;11464:3;11502:6;11496:13;11518:53;11564:6;11559:3;11552:4;11544:6;11540:17;11518:53;:::i;:::-;11634:13;;11593:16;;;;11656:57;11634:13;11593:16;11690:4;11678:17;;11656:57;:::i;:::-;-1:-1:-1;;;11735:20:1;;11764:22;;;11813:1;11802:13;;11184:637;-1:-1:-1;;;;11184:637:1:o;13359:135::-;13398:3;13419:17;;;13416:43;;13439:18;;:::i;:::-;-1:-1:-1;13486:1:1;13475:13;;13359:135::o;13499:112::-;13531:1;13557;13547:35;;13562:18;;:::i;:::-;-1:-1:-1;13596:9:1;;13499:112::o;13616:489::-;-1:-1:-1;;;;;13885:15:1;;;13867:34;;13937:15;;13932:2;13917:18;;13910:43;13984:2;13969:18;;13962:34;;;14032:3;14027:2;14012:18;;14005:31;;;13810:4;;14053:46;;14079:19;;14071:6;14053:46;:::i;:::-;14045:54;13616:489;-1:-1:-1;;;;;;13616:489:1:o;14110:249::-;14179:6;14232:2;14220:9;14211:7;14207:23;14203:32;14200:52;;;14248:1;14245;14238:12;14200:52;14280:9;14274:16;14299:30;14323:5;14299:30;:::i

Swarm Source

ipfs://082e0c7475da18d9d3ec2253ca54e1556f388da2d7b7b08be061c9c06241c7e5

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