Token

HoneyHeaven (HoneyHeaven)

ERC-721

Overview

Max Total Supply

959 HoneyHeaven

Holders

392

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xaa84096f75d251c719e53ac3ea93d208331bf7c9

Filtered by Token Holder

0x8C8B692EE84Fc1370163151D53EDF13529A296A5

thephotograbbear.eth

Balance

3 HoneyHeaven

0x8c8b692ee84fc1370163151d53edf13529a296a5

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

HoneyHeaven

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 2023-01-29
*/

// 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 HoneyHeaven is ERC721A, Ownable, ERC2981, OperatorFilterer {
    uint256 public price = 0.003 ether;
    uint256 public maxPerTransaction = 10;
    uint256 public immutable supply = 1333;
    string public _baseTokenURI = 'ipfs://Qmbwg1oVrEnBUpsGCkAsE3uiP5WsG17gndXNmh1uBiB2RT/';

    uint256 public freeUntil = 1333;
    uint256 public freebiesPerWallet = 1;

    enum SaleState {
        CLOSED,
        OPEN
    }
    SaleState public saleState = SaleState.CLOSED;

    constructor() ERC721A("HoneyHeaven", "HoneyHeaven") 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 (qty > maxPerTransaction) revert InvalidQuantity();

        uint256 freeMintsLeftForWallet = freebiesPerWallet - balanceOf(msg.sender);
        uint256 freeMintsToBeUsed = qty < freeMintsLeftForWallet ? qty : freeMintsLeftForWallet;
        if (totalSupply() >= freeUntil) {
          freeMintsToBeUsed = 0;
        }
        uint256 payableAmount = qty - freeMintsToBeUsed;
        require(msg.value >= price * payableAmount, 'Insufficient funds!');

        _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 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":"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":"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":[],"name":"freeUntil","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"freebiesPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"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":[{"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 HoneyHeaven.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":"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:3990:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67264:204;;;;;;;;;;-1:-1:-1;67264:204:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;67264:204:0;;;;;;;;67086:170;;;;;;;;;;-1:-1:-1;67086:170:0;;;;;:::i;:::-;;:::i;:::-;;64306:38;;;;;;;;;;;;;;;;;;1287:25:1;;;1275:2;1260:18;64306:38: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;64484:36::-;;;;;;;;;;;;;;;;28930:303;;;;;;;;;;-1:-1:-1;65628:1:0;29184:12;28974:7;29168:13;:28;-1:-1:-1;;29168:46:0;28930:303;;67476:197;;;;;;;;;;-1:-1:-1;67476: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;66088:180:0;;;;;;;;;;-1:-1:-1;66088:180:0;;;;;:::i;:::-;;:::i;66898:::-;;;;;;;;;;;;;:::i;67681:205::-;;;;;;;;;;-1:-1:-1;67681:205:0;;;;;:::i;:::-;;:::i;64262:37::-;;;;;;;;;;;;;;;;65767:104;;;;;;;;;;-1:-1:-1;65767:104:0;;;;;:::i;:::-;;:::i;65977:103::-;;;;;;;;;;-1:-1:-1;65977:103:0;;;;;:::i;:::-;;:::i;64589:45::-;;;;;;;;;;-1:-1:-1;64589:45:0;;;;;;;;;;;;;;;:::i;32602:125::-;;;;;;;;;;-1:-1:-1;32602:125:0;;;;;:::i;:::-;;:::i;66276:500::-;;;;;;;;;;-1:-1:-1;66276: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;;65879:90;;;;;;;;;;-1:-1:-1;65879:90:0;;;;;:::i;:::-;;:::i;32963:104::-;;;;;;;;;;;;;:::i;64221:34::-;;;;;;;;;;;;;;;;64829:699;;;;;;:::i;:::-;;:::i;34582:287::-;;;;;;;;;;-1:-1:-1;34582:287:0;;;;;:::i;:::-;;:::i;2425:141::-;;;;;;;;;;;;2523:42;2425:141;;64446:31;;;;;;;;;;;;;;;;67894:239;;;;;;;;;;-1:-1:-1;67894:239:0;;;;;:::i;:::-;;:::i;66784:106::-;;;;;;;;;;-1:-1:-1;66784:106:0;;;;;:::i;:::-;;:::i;33138:327::-;;;;;;;;;;-1:-1:-1;33138:327:0;;;;;:::i;:::-;;:::i;64351: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;67264:204::-;67395:4;67424:36;67448:11;67424:23;:36::i;:::-;67417:43;67264:204;-1:-1:-1;;67264:204:0:o;67086:170::-;48575:13;:11;:13::i;:::-;67204:44:::1;67223:8;67233:14;67204:18;:44::i;:::-;67086: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;67476:197::-;67611:4;2523:42;3663:43;:47;3659:699;;3950:10;-1:-1:-1;;;;;3942:18:0;;;3938:85;;67628:37:::1;67647:4;67653:2;67657:7;67628: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;67628:37:::1;67647:4;67653:2;67657:7;67628:18;:37::i;:::-;67476: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;66088:180::-;48575:13;:11;:13::i;:::-;66200:6:::1;66189:7;66195:1;66189:3:::0;:7:::1;:::i;:::-;66172:13;;:25;;;;:::i;:::-;:34;66168:56;;;66215:9;;-1:-1:-1::0;;;66215:9:0::1;;;;;;;;;;;66168:56;66235:25;66245:9;66256:3;66235:9;:25::i;66898:180::-:0;48575:13;:11;:13::i;:::-;66949:12:::1;66975:7;48762:6:::0;;-1:-1:-1;;;;;48762:6:0;;48689:87;66975:7:::1;-1:-1:-1::0;;;;;66967:21:0::1;66996;66967:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66948:74;;;67038:7;67033:37;;67054:16;;-1:-1:-1::0;;;67054:16:0::1;;;;;;;;;;;67033:37;66937:141;66898:180::o:0;67681:205::-;67820:4;2523:42;3663:43;:47;3659:699;;3950:10;-1:-1:-1;;;;;3942:18:0;;;3938:85;;67837:41:::1;67860:4;67866:2;67870:7;67837: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;67837:41:::1;67860:4;67866:2;67870:7;67837:22;:41::i;65767:104::-:0;48575:13;:11;:13::i;:::-;65840:23;;::::1;::::0;:13:::1;::::0;:23:::1;::::0;::::1;::::0;::::1;:::i;65977:103::-:0;48575:13;:11;:13::i;:::-;66065:6:::1;66055:17;;;;;;;;;;:::i;:::-;66043:9;:29:::0;;-1:-1:-1;;66043:29:0::1;::::0;;;;::::1;;;;;;:::i;:::-;;;;;;65977: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;66276:500::-;48575:13;:11;:13::i;:::-;66427:10;66459:28;;::::1;66455:59;;66496:18;;-1:-1:-1::0;;;66496:18:0::1;;;;;;;;;;;66455:59;66532:9;66527:242;66551:13;66547:1;:17;66527:242;;;66619:6;66609:4;;66614:1;66609:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;66587:29:0::1;66604:1;66588:13;;:17;;;;:::i;:::-;66587:29;;;;:::i;:::-;:38;66583:60;;;66634:9;;-1:-1:-1::0;;;66634:9:0::1;;;;;;;;;;;66583:60;66660:33;66670:10;;66681:1;66670:13;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;66685:4;;66690:1;66685:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;66660:33:0::1;:9;:33::i;:::-;66739:3;;66527:242;;;;66392:384;66276: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;65879:90::-;48575:13;:11;:13::i;:::-;65945:5:::1;:16:::0;65879:90::o;32963:104::-;33019:13;33052:7;33045:14;;;;;:::i;64829:699::-;64901:14;64888:9;;;;;:27;;;;;;;:::i;:::-;;64884:54;;64924:14;;-1:-1:-1;;;64924:14:0;;;;;;;;;;;64884:54;64981:6;64970:7;64976:1;64970:3;:7;:::i;:::-;64953:13;;:25;;;;:::i;:::-;:34;64949:56;;;64996:9;;-1:-1:-1;;;64996:9:0;;;;;;;;;;;64949:56;65028:17;;65022:3;:23;65018:53;;;65054:17;;-1:-1:-1;;;65054:17:0;;;;;;;;;;;65018:53;65084:30;65137:21;65147:10;65137:9;:21::i;:::-;65117:17;;:41;;;;:::i;:::-;65084:74;;65169:25;65203:22;65197:3;:28;:59;;65234:22;65197:59;;;65228:3;65197:59;65169:87;;65288:9;;65271:13;65628:1;29184:12;28974:7;29168:13;-1:-1:-1;;29168:28:0;;;:46;;28930:303;65271:13;:26;65267:78;;-1:-1:-1;65332:1:0;65267:78;65355:21;65379:23;65385:17;65379:3;:23;:::i;:::-;65355:47;;65442:13;65434:5;;:21;;;;:::i;:::-;65421:9;:34;;65413:66;;;;-1:-1:-1;;;65413:66:0;;11386:2:1;65413:66:0;;;11368:21:1;11425:2;11405:18;;;11398:30;-1:-1:-1;;;11444:18:1;;;11437:49;11503:18;;65413:66:0;11184:343:1;65413:66:0;65492:26;65502:10;65514:3;65492: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;67894:239::-;68061:4;2523:42;3663:43;:47;3659:699;;3950:10;-1:-1:-1;;;;;3942:18:0;;;3938:85;;68078:47:::1;68101:4;68107:2;68111:7;68120:4;68078: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;68078:47:::1;68101:4;68107:2;68111:7;68120:4;68078:22;:47::i;:::-;67894:239:::0;;;;;:::o;66784:106::-;48575:13;:11;:13::i;:::-;66858:17:::1;:24:::0;66784: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;64351: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;;12376:2:1;49676:73:0::1;::::0;::::1;12358:21:1::0;12415:2;12395:18;;;12388:30;12454:34;12434:18;;;12427:62;-1:-1:-1;;;12505:18:1;;;12498:36;12551:19;;49676:73:0::1;12174: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;;12783:2:1;48910:68:0;;;12765:21:1;;;12802:18;;;12795:30;12861:34;12841:18;;;12834:62;12913:18;;48910:68:0;12581:356:1;53812:332:0;53528:5;-1:-1:-1;;;;;53915:33:0;;;;53907:88;;;;-1:-1:-1;;;53907:88:0;;13144:2:1;53907:88:0;;;13126:21:1;13183:2;13163:18;;;13156:30;13222:34;13202:18;;;13195:62;-1:-1:-1;;;13273:18:1;;;13266:40;13323:19;;53907:88:0;12942:406:1;53907:88:0;-1:-1:-1;;;;;54014:22:0;;54006:60;;;;-1:-1:-1;;;54006:60:0;;13555:2:1;54006:60:0;;;13537:21:1;13594:2;13574:18;;;13567:30;13633:27;13613:18;;;13606:55;13678:18;;54006:60:0;13353: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;65628: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;;65628: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;;;;;;;;;;;65645:114;65705:13;65738;65731: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;67476: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;67476: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:254::-;3659:6;3667;3720:2;3708:9;3699:7;3695:23;3691:32;3688:52;;;3736:1;3733;3726:12;3688:52;3772:9;3759:23;3749:33;;3801:38;3835:2;3824:9;3820:18;3801:38;:::i;:::-;3791:48;;3591:254;;;;;:::o;3850:127::-;3911:10;3906:3;3902:20;3899:1;3892:31;3942:4;3939:1;3932:15;3966:4;3963:1;3956:15;3982:632;4047:5;-1:-1:-1;;;;;4118:2:1;4110:6;4107:14;4104:40;;;4124:18;;:::i;:::-;4199:2;4193:9;4167:2;4253:15;;-1:-1:-1;;4249:24:1;;;4275:2;4245:33;4241:42;4229:55;;;4299:18;;;4319:22;;;4296:46;4293:72;;;4345:18;;:::i;:::-;4385:10;4381:2;4374:22;4414:6;4405:15;;4444:6;4436;4429:22;4484:3;4475:6;4470:3;4466:16;4463:25;4460:45;;;4501:1;4498;4491:12;4460:45;4551:6;4546:3;4539:4;4531:6;4527:17;4514:44;4606:1;4599:4;4590:6;4582;4578:19;4574:30;4567:41;;;;3982:632;;;;;:::o;4619:451::-;4688:6;4741:2;4729:9;4720:7;4716:23;4712:32;4709:52;;;4757:1;4754;4747:12;4709:52;4797:9;4784:23;-1:-1:-1;;;;;4822:6:1;4819:30;4816:50;;;4862:1;4859;4852:12;4816:50;4885:22;;4938:4;4930:13;;4926:27;-1:-1:-1;4916:55:1;;4967:1;4964;4957:12;4916:55;4990:74;5056:7;5051:2;5038:16;5033:2;5029;5025:11;4990:74;:::i;5075:269::-;5132:6;5185:2;5173:9;5164:7;5160:23;5156:32;5153:52;;;5201:1;5198;5191:12;5153:52;5240:9;5227:23;5290:4;5283:5;5279:16;5272:5;5269:27;5259:55;;5310:1;5307;5300:12;5349:127;5410:10;5405:3;5401:20;5398:1;5391:31;5441:4;5438:1;5431:15;5465:4;5462:1;5455:15;5481:342;5627:2;5612:18;;5660:1;5649:13;;5639:144;;5705:10;5700:3;5696:20;5693:1;5686:31;5740:4;5737:1;5730:15;5768:4;5765:1;5758:15;5639:144;5792:25;;;5481:342;:::o;5828:366::-;5890:8;5900:6;5954:3;5947:4;5939:6;5935:17;5931:27;5921:55;;5972:1;5969;5962:12;5921:55;-1:-1:-1;5995:20:1;;-1:-1:-1;;;;;6027:30:1;;6024:50;;;6070:1;6067;6060:12;6024:50;6107:4;6099:6;6095:17;6083:29;;6167:3;6160:4;6150:6;6147:1;6143:14;6135:6;6131:27;6127:38;6124:47;6121:67;;;6184:1;6181;6174:12;6199:770;6320:6;6328;6336;6344;6397:2;6385:9;6376:7;6372:23;6368:32;6365:52;;;6413:1;6410;6403:12;6365:52;6453:9;6440:23;-1:-1:-1;;;;;6523:2:1;6515:6;6512:14;6509:34;;;6539:1;6536;6529:12;6509:34;6578:69;6639:7;6630:6;6619:9;6615:22;6578:69;:::i;:::-;6666:8;;-1:-1:-1;6552:95:1;-1:-1:-1;6754:2:1;6739:18;;6726:32;;-1:-1:-1;6770:16:1;;;6767:36;;;6799:1;6796;6789:12;6767:36;;6838:71;6901:7;6890:8;6879:9;6875:24;6838:71;:::i;:::-;6199:770;;;;-1:-1:-1;6928:8:1;-1:-1:-1;;;;6199:770:1:o;6974:186::-;7033:6;7086:2;7074:9;7065:7;7061:23;7057:32;7054:52;;;7102:1;7099;7092:12;7054:52;7125:29;7144:9;7125:29;:::i;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;11532:637;11812:3;11850:6;11844:13;11866:53;11912:6;11907:3;11900:4;11892:6;11888:17;11866:53;:::i;:::-;11982:13;;11941:16;;;;12004:57;11982:13;11941:16;12038:4;12026:17;;12004:57;:::i;:::-;-1:-1:-1;;;12083:20:1;;12112:22;;;12161:1;12150:13;;11532:637;-1:-1:-1;;;;11532:637:1:o;13707:135::-;13746:3;13767:17;;;13764:43;;13787:18;;:::i;:::-;-1:-1:-1;13834:1:1;13823:13;;13707:135::o;13847:112::-;13879:1;13905;13895:35;;13910:18;;:::i;:::-;-1:-1:-1;13944:9:1;;13847:112::o;13964:489::-;-1:-1:-1;;;;;14233:15:1;;;14215:34;;14285:15;;14280:2;14265:18;;14258:43;14332:2;14317:18;;14310:34;;;14380:3;14375:2;14360:18;;14353:31;;;14158:4;;14401:46;;14427:19;;14419:6;14401:46;:::i;:::-;14393:54;13964:489;-1:-1:-1;;;;;;13964:489:1:o;14458:249::-;14527:6;14580:2;14568:9;14559:7;14555:23;14551:32;14548:52;;;14596:1;14593;14586:12;14548:52;14628:9;14622:16;14647:30;14671:5;14647:30;:::i

Swarm Source

ipfs://275c75f2f1f484ea637802a78da0f12b38c80e0ea3d2804596d294220c4c215c

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