Token

PUMA Nitro Token (NITKN)

ERC-721

NFT

Overview

Max Total Supply

0 NITKN

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xd96463a406e734debd0f3eabf2343bdc7a86ac83

Filtered by Token Holder

0x0000000000000000000000000000000000000000

Null: 0x000...000

Balance

0 NITKN

0x0000000000000000000000000000000000000000

OVERVIEW

PUMA’s first owned and operated Nitro NFT project.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

PumaNitroToken

Compiler Version

v0.8.7+commit.e28d00a7

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-08-20
*/

// SPDX-License-Identifier: MIT and GPL-3.0

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

pragma solidity ^0.8.0;

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

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

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

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

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


// File @openzeppelin/contracts/utils/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/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/token/ERC721/extensions/[email protected]
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}


// 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/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/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 contracts/ERC721A.sol
// Creator: Chiru Labs

pragma solidity ^0.8.4;


error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error BurnedQueryForZeroAddress();
error AuxQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
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 1;
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     * @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) {
        if (owner == address(0)) revert MintedQueryForZeroAddress();
        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) {
        if (owner == address(0)) revert BurnedQueryForZeroAddress();
        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) {
        if (owner == address(0)) revert AuxQueryForZeroAddress();
        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 {
        if (owner == address(0)) revert AuxQueryForZeroAddress();
        _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())) : '';
    }

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

        bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
            isApprovedForAll(prevOwnership.addr, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

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

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

            _ownerships[tokenId].addr = to;
            _ownerships[tokenId].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;
            if (_ownerships[nextTokenId].addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId < _currentIndex) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

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

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

        _beforeTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);

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

        // 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[prevOwnership.addr].balance -= 1;
            _addressData[prevOwnership.addr].numberBurned += 1;

            // Keep track of who burned the token, and the timestamp of burning.
            _ownerships[tokenId].addr = prevOwnership.addr;
            _ownerships[tokenId].startTimestamp = uint64(block.timestamp);
            _ownerships[tokenId].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;
            if (_ownerships[nextTokenId].addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId < _currentIndex) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(prevOwnership.addr, address(0), tokenId);
        _afterTokenTransfers(prevOwnership.addr, 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 contracts/mocks/StartTokenIdHelper.sol
// Creators: Chiru Labs

pragma solidity ^0.8.4;

/**
 * This Helper is used to return a dynmamic value in the overriden _startTokenId() function.
 * Extending this Helper before the ERC721A contract give us access to the herein set `startTokenId`
 * to be returned by the overriden `_startTokenId()` function of ERC721A in the ERC721AStartTokenId mocks.
 */
contract StartTokenIdHelper {
    uint256 public immutable startTokenId;

    constructor(uint256 startTokenId_) {
        startTokenId = startTokenId_;
    }
}


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

/**
PumaNitroToken Smart Contract Development by @WumboLabs
**/

pragma solidity >=0.8.0 <0.9.0;


contract PumaNitroToken is ERC721A, Ownable {
    using Strings for uint256;

    address public NitroPassContract;

    /// All allowlist set on Merkle Tree
    bytes32 public MERKLEROOT = 0x030dbae32c900445b3b687e37c13da2060ed206d1ce3942bb714b4903008ce68;
    uint256 constant MAX_SUPPLY = 4000;

    /// PUMA x Catblox NFT holders on August 19th, 2022 9 PM PST
    mapping(address => uint256 ) public holderSnapshot;

    struct snapshotAddress {
        address user;
        uint256 amount;
    }

    enum Status {
        NOT_LIVE,
        WHITELIST_SNAPSHOT,
        PUBLIC,
        ENDED
    }

    /// Minting Variables
    string public URI = "ipfs://QmUHJpkxd8ZwXE9G1tAbDyEk4xa6fptAFjVS6AUQtD2WBh/pumanitrotoken.json";
    Status public state;
    uint256 public claimCount;

    constructor() ERC721A("PUMA Nitro Token", "NITKN") {
    }

    function setNitroPassContract(address _NitroPassContract) external onlyOwner {
        NitroPassContract = _NitroPassContract;
    }

    /// Called by Nitro Pass Contract to burn Nitro Token on minting Nitro Pass
    function burnNitroTokenForNitroPass(uint256 NitroTokenId) external {
        require(msg.sender == NitroPassContract, "Invalid burner address");
        _burn(NitroTokenId);
    }

    function burnAllNitroTokens() public onlyOwner {
        require(state == Status.ENDED, "PUMA Nitro Token: Still Live");
        for (uint256 _tokenId=0; _tokenId<MAX_SUPPLY; _tokenId++) {
            if(_exists(_tokenId)) {
                _burn(_tokenId);
            }
        }
    }

    function burnNitroToken(uint256 tokenId) public onlyOwner {
        require(state == Status.ENDED, "PUMA Nitro Token: Still Live");
        require(_exists(tokenId), 'Token does not exist');
        _burn(tokenId);
    }

    /// Claimable by someone on snapshot or allowlist 
    function claim(bytes32[] calldata _proof) external {
        require(msg.sender == tx.origin, "PUMA Nitro Token: Contract Interaction Not Allowed");
        require(state == Status.WHITELIST_SNAPSHOT, "PUMA Nitro Token: Claim Is Not Live");
        require(MerkleProof.verify(_proof,MERKLEROOT,keccak256(abi.encodePacked(msg.sender))),"Invalid proof.");
        uint256 amountClaimable = holderSnapshot[msg.sender];
        uint256 amountMinted = _numberMinted(msg.sender);
        uint256 netAmountClaimable = amountClaimable - amountMinted;
        if (amountClaimable > 0){
            require(amountClaimable > amountMinted);
            require(claimCount + netAmountClaimable <= MAX_SUPPLY, "PUMA Nitro Token: Mint Supply Exceeded");
            claimCount += netAmountClaimable;
            holderSnapshot[msg.sender] = 0;
        } else {
            require(amountMinted < 1);
            require(claimCount + 1 <= MAX_SUPPLY, "PUMA Nitro Token: Mint Supply Exceeded");
            netAmountClaimable = 1;
            claimCount ++;
        }
        _safeMint(msg.sender, netAmountClaimable);
    }
    
    function publicClaim() external {
        require(msg.sender == tx.origin, "PUMA Nitro Token: Contract Interaction Not Allowed");
        require(state == Status.PUBLIC, "PUMA Nitro Token: Public not live");
        require(_numberMinted(msg.sender) < 1, "PUMA Nitro Token: Exceeds Max Per Wallet");
        require(claimCount + 1 <= MAX_SUPPLY, "PUMA Nitro Token: Mint Supply Exceeded");
        claimCount++;
        _safeMint(msg.sender, 1);
    }

    function setSnapshot(snapshotAddress[] calldata addresses) external onlyOwner {
        for(uint256 i = 0; i < addresses.length; i++){
            holderSnapshot[addresses[i].user] = addresses[i].amount;
        }
    }

    function resetSnapshot(address[] calldata addresses) external onlyOwner {
        for (uint256 i = 0; i < addresses.length; i++) {
            holderSnapshot[addresses[i]] = 0;
        }
    }
    
    function addSnapshot(address _address, uint256 _amount) external onlyOwner {
        require(holderSnapshot[_address] == 0, "PUMA Nitro Token: Already in allowlist");
        holderSnapshot[_address] = _amount;
    }
  
    function removeSnapshot(address _newEntry) external onlyOwner {
        require(holderSnapshot[_newEntry] != 0, "PUMA Nitro Token: Previous not in allowlist");
        holderSnapshot[_newEntry] = 0;
    }

    function isWhitelisted(bytes32[] memory proof, bytes32 leaf) external view returns (bool) {
        return MerkleProof.verify(proof, MERKLEROOT, leaf);
    }

    function setState(Status _state) external onlyOwner {
        state = _state;
    }

    function setMerkleRoot(bytes32 _root) external onlyOwner {
        MERKLEROOT = _root;
    }
    
    function setURI(string calldata _newURI) external onlyOwner {
        URI = _newURI;
    }

    function tokenURI(uint256 _tokenId) public view override returns (string memory) {
        require(_exists(_tokenId), "ERC721Metadata: URI query for nonexistent token");
        return URI;
    }

    function withdrawMoney() external onlyOwner {
    (bool success, ) = msg.sender.call{value: address(this).balance}("");
    require(success, "Withdraw failed.");
    }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"MintedQueryForZeroAddress","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"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":"MERKLEROOT","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NitroPassContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"URI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"addSnapshot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnAllNitroTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burnNitroToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"NitroTokenId","type":"uint256"}],"name":"burnNitroTokenForNitroPass","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimCount","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":"","type":"address"}],"name":"holderSnapshot","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"bytes32","name":"leaf","type":"bytes32"}],"name":"isWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicClaim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newEntry","type":"address"}],"name":"removeSnapshot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"}],"name":"resetSnapshot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_root","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_NitroPassContract","type":"address"}],"name":"setNitroPassContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct PumaNitroToken.snapshotAddress[]","name":"addresses","type":"tuple[]"}],"name":"setSnapshot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"enum PumaNitroToken.Status","name":"_state","type":"uint8"}],"name":"setState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newURI","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"state","outputs":[{"internalType":"enum PumaNitroToken.Status","name":"","type":"uint8"}],"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":"withdrawMoney","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

0x608060405234801561001057600080fd5b50600436106102325760003560e01c806370a0823111610130578063b391c508116100b8578063e2dea63d1161007c578063e2dea63d14610491578063e3ce8ac0146104b1578063e985e9c5146104c4578063ecd5f7a914610500578063f2fde38b1461051357600080fd5b8063b391c50814610435578063b88d4fde14610448578063b92c0aa51461045b578063c19d93fb14610464578063c87b56dd1461047e57600080fd5b80638da4d3c9116100ff5780638da4d3c9146103f85780638da5cb5b1461040157806395d89b4114610412578063a22cb4651461041a578063ac4460021461042d57600080fd5b806370a08231146103b7578063715018a6146103ca5780637397727a146103d25780637cb64759146103e557600080fd5b806339304513116101be57806357614ae51161018257806357614ae514610358578063596d99c01461036b578063598a5f101461037e5780636352211e1461039157806364ec9407146103a457600080fd5b8063393045131461030457806342842e0e1461030c5780634b11b4b21461031f578063529f5e2b1461033257806356de96db1461034557600080fd5b8063095ea7b311610205578063095ea7b3146102b45780631141d7de146102c757806318160ddd146102cf5780631b415239146102e957806323b872dd146102f157600080fd5b806301ffc9a71461023757806302fe53051461025f57806306fdde0314610274578063081812fc14610289575b600080fd5b61024a6102453660046120ba565b610526565b60405190151581526020015b60405180910390f35b61027261026d366004612115565b610578565b005b61027c610591565b6040516102569190612226565b61029c6102973660046120a1565b610623565b6040516001600160a01b039091168152602001610256565b6102726102c2366004611f10565b610667565b61027c6106f0565b60015460005403600019015b604051908152602001610256565b61027261077e565b6102726102ff366004611dd9565b6108d1565b6102726108dc565b61027261031a366004611dd9565b610983565b61027261032d366004611f3a565b61099e565b610272610340366004611d8b565b610a0a565b6102726103533660046120f4565b610a34565b60095461029c906001600160a01b031681565b610272610379366004611d8b565b610a63565b61027261038c366004611f10565b610afe565b61029c61039f3660046120a1565b610b97565b6102726103b23660046120a1565b610ba9565b6102db6103c5366004611d8b565b610c6c565b610272610cba565b61024a6103e0366004611f7b565b610ccc565b6102726103f33660046120a1565b610ce2565b6102db600e5481565b6008546001600160a01b031661029c565b61027c610cef565b610272610428366004611ed4565b610cfe565b610272610d94565b610272610443366004611f3a565b610e27565b610272610456366004611e15565b611068565b6102db600a5481565b600d546104719060ff1681565b60405161025691906121fe565b61027c61048c3660046120a1565b6110b9565b6102db61049f366004611d8b565b600b6020526000908152604090205481565b6102726104bf3660046120a1565b6111ba565b61024a6104d2366004611da6565b6001600160a01b03918216600090815260076020908152604080832093909416825291909152205460ff1690565b61027261050e36600461202d565b61120d565b610272610521366004611d8b565b611294565b60006001600160e01b031982166380ac58cd60e01b148061055757506001600160e01b03198216635b5e139f60e01b145b8061057257506301ffc9a760e01b6001600160e01b03198316145b92915050565b61058061130a565b61058c600c8383611c8b565b505050565b6060600280546105a090612330565b80601f01602080910402602001604051908101604052809291908181526020018280546105cc90612330565b80156106195780601f106105ee57610100808354040283529160200191610619565b820191906000526020600020905b8154815290600101906020018083116105fc57829003601f168201915b5050505050905090565b600061062e82611364565b61064b576040516333d1c03960e21b815260040160405180910390fd5b506000908152600660205260409020546001600160a01b031690565b600061067282610b97565b9050806001600160a01b0316836001600160a01b031614156106a75760405163250fdee360e21b815260040160405180910390fd5b336001600160a01b038216148015906106c757506106c581336104d2565b155b156106e5576040516367d9dca160e11b815260040160405180910390fd5b61058c83838361139d565b600c80546106fd90612330565b80601f016020809104026020016040519081016040528092919081815260200182805461072990612330565b80156107765780601f1061074b57610100808354040283529160200191610776565b820191906000526020600020905b81548152906001019060200180831161075957829003601f168201915b505050505081565b3332146107a65760405162461bcd60e51b815260040161079d9061227f565b60405180910390fd5b6002600d5460ff1660038111156107bf576107bf61239c565b146108165760405162461bcd60e51b815260206004820152602160248201527f50554d41204e6974726f20546f6b656e3a205075626c6963206e6f74206c69766044820152606560f81b606482015260840161079d565b6001610821336113f9565b1061087f5760405162461bcd60e51b815260206004820152602860248201527f50554d41204e6974726f20546f6b656e3a2045786365656473204d61782050656044820152671c8815d85b1b195d60c21b606482015260840161079d565b610fa0600e5460016108919190612301565b11156108af5760405162461bcd60e51b815260040161079d90612239565b600e80549060006108bf8361236b565b91905055506108cf33600161144e565b565b61058c83838361146c565b6108e461130a565b6003600d5460ff1660038111156108fd576108fd61239c565b1461094a5760405162461bcd60e51b815260206004820152601c60248201527f50554d41204e6974726f20546f6b656e3a205374696c6c204c69766500000000604482015260640161079d565b60005b610fa08110156109805761096081611364565b1561096e5761096e8161166b565b806109788161236b565b91505061094d565b50565b61058c83838360405180602001604052806000815250611068565b6109a661130a565b60005b8181101561058c576000600b60008585858181106109c9576109c96123b2565b90506020020160208101906109de9190611d8b565b6001600160a01b0316815260208101919091526040016000205580610a028161236b565b9150506109a9565b610a1261130a565b600980546001600160a01b0319166001600160a01b0392909216919091179055565b610a3c61130a565b600d805482919060ff19166001836003811115610a5b57610a5b61239c565b021790555050565b610a6b61130a565b6001600160a01b0381166000908152600b6020526040902054610ae45760405162461bcd60e51b815260206004820152602b60248201527f50554d41204e6974726f20546f6b656e3a2050726576696f7573206e6f74206960448201526a1b88185b1b1bdddb1a5cdd60aa1b606482015260840161079d565b6001600160a01b03166000908152600b6020526040812055565b610b0661130a565b6001600160a01b0382166000908152600b602052604090205415610b7b5760405162461bcd60e51b815260206004820152602660248201527f50554d41204e6974726f20546f6b656e3a20416c726561647920696e20616c6c6044820152651bdddb1a5cdd60d21b606482015260840161079d565b6001600160a01b039091166000908152600b6020526040902055565b6000610ba2826117d5565b5192915050565b610bb161130a565b6003600d5460ff166003811115610bca57610bca61239c565b14610c175760405162461bcd60e51b815260206004820152601c60248201527f50554d41204e6974726f20546f6b656e3a205374696c6c204c69766500000000604482015260640161079d565b610c2081611364565b610c635760405162461bcd60e51b8152602060048201526014602482015273151bdad95b88191bd95cc81b9bdd08195e1a5cdd60621b604482015260640161079d565b6109808161166b565b60006001600160a01b038216610c95576040516323d3ad8160e21b815260040160405180910390fd5b506001600160a01b03166000908152600560205260409020546001600160401b031690565b610cc261130a565b6108cf60006118fc565b6000610cdb83600a548461194e565b9392505050565b610cea61130a565b600a55565b6060600380546105a090612330565b6001600160a01b038216331415610d285760405163b06307db60e01b815260040160405180910390fd5b3360008181526007602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b610d9c61130a565b604051600090339047908381818185875af1925050503d8060008114610dde576040519150601f19603f3d011682016040523d82523d6000602084013e610de3565b606091505b50509050806109805760405162461bcd60e51b815260206004820152601060248201526f2bb4ba34323930bb903330b4b632b21760811b604482015260640161079d565b333214610e465760405162461bcd60e51b815260040161079d9061227f565b6001600d5460ff166003811115610e5f57610e5f61239c565b14610eb85760405162461bcd60e51b815260206004820152602360248201527f50554d41204e6974726f20546f6b656e3a20436c61696d204973204e6f74204c60448201526269766560e81b606482015260840161079d565b610f2d82828080602002602001604051908101604052809392919081815260200183836020028082843760009201919091525050600a546040516bffffffffffffffffffffffff193360601b16602082015290925060340190506040516020818303038152906040528051906020012061194e565b610f6a5760405162461bcd60e51b815260206004820152600e60248201526d24b73b30b634b210383937b7b31760911b604482015260640161079d565b336000818152600b602052604081205491610f84906113f9565b90506000610f928284612319565b9050821561100157818311610fa657600080fd5b610fa081600e54610fb79190612301565b1115610fd55760405162461bcd60e51b815260040161079d90612239565b80600e6000828254610fe79190612301565b9091555050336000908152600b6020526040812055611057565b6001821061100e57600080fd5b610fa0600e5460016110209190612301565b111561103e5760405162461bcd60e51b815260040161079d90612239565b50600e805460019160006110518361236b565b91905055505b611061338261144e565b5050505050565b61107384848461146c565b6001600160a01b0383163b15158015611095575061109384848484611964565b155b156110b3576040516368d2bf6b60e11b815260040160405180910390fd5b50505050565b60606110c482611364565b6111285760405162461bcd60e51b815260206004820152602f60248201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60448201526e3732bc34b9ba32b73a103a37b5b2b760891b606482015260840161079d565b600c805461113590612330565b80601f016020809104026020016040519081016040528092919081815260200182805461116190612330565b80156111ae5780601f10611183576101008083540402835291602001916111ae565b820191906000526020600020905b81548152906001019060200180831161119157829003601f168201915b50505050509050919050565b6009546001600160a01b03163314610c635760405162461bcd60e51b8152602060048201526016602482015275496e76616c6964206275726e6572206164647265737360501b604482015260640161079d565b61121561130a565b60005b8181101561058c57828282818110611232576112326123b2565b90506040020160200135600b6000858585818110611252576112526123b2565b6112689260206040909202019081019150611d8b565b6001600160a01b031681526020810191909152604001600020558061128c8161236b565b915050611218565b61129c61130a565b6001600160a01b0381166113015760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161079d565b610980816118fc565b6008546001600160a01b031633146108cf5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161079d565b600081600111158015611378575060005482105b8015610572575050600090815260046020526040902054600160e01b900460ff161590565b60008281526006602052604080822080546001600160a01b0319166001600160a01b0387811691821790925591518593918516917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591a4505050565b60006001600160a01b038216611422576040516335ebb31960e01b815260040160405180910390fd5b506001600160a01b0316600090815260056020526040902054600160401b90046001600160401b031690565b611468828260405180602001604052806000815250611a5b565b5050565b6000611477826117d5565b80519091506000906001600160a01b0316336001600160a01b031614806114a5575081516114a590336104d2565b806114c05750336114b584610623565b6001600160a01b0316145b9050806114e057604051632ce44b5f60e11b815260040160405180910390fd5b846001600160a01b031682600001516001600160a01b0316146115155760405162a1148160e81b815260040160405180910390fd5b6001600160a01b03841661153c57604051633a954ecd60e21b815260040160405180910390fd5b61154c600084846000015161139d565b6001600160a01b038581166000908152600560209081526040808320805467ffffffffffffffff198082166001600160401b0392831660001901831617909255898616808652838620805493841693831660019081018416949094179055898652600490945282852080546001600160e01b031916909417600160a01b4290921691909102179092559086018083529120549091166116365760005481101561163657825160008281526004602090815260409091208054918601516001600160401b0316600160a01b026001600160e01b03199092166001600160a01b03909316929092171790555b5082846001600160a01b0316866001600160a01b03166000805160206123f583398151915260405160405180910390a4611061565b6000611676826117d5565b9050611688600083836000015161139d565b80516001600160a01b039081166000908152600560209081526040808320805467ffffffffffffffff1981166001600160401b0391821660001901821617909155855185168452818420805467ffffffffffffffff60801b198116600160801b9182900484166001908101851690920217909155865188865260049094528285208054600160e01b9588166001600160e01b031990911617600160a01b42909416939093029290921760ff60e01b191693909317905590850180835291205490911661179f5760005481101561179f57815160008281526004602090815260409091208054918501516001600160401b0316600160a01b026001600160e01b03199092166001600160a01b03909316929092171790555b50805160405183916000916001600160a01b03909116906000805160206123f5833981519152908390a450506001805481019055565b60408051606081018252600080825260208201819052918101919091528180600111158015611805575060005481105b156118e357600081815260046020908152604091829020825160608101845290546001600160a01b0381168252600160a01b81046001600160401b031692820192909252600160e01b90910460ff161515918101829052906118e15780516001600160a01b031615611878579392505050565b5060001901600081815260046020908152604091829020825160608101845290546001600160a01b038116808352600160a01b82046001600160401b031693830193909352600160e01b900460ff16151592810192909252156118dc579392505050565b611878565b505b604051636f96cda160e11b815260040160405180910390fd5b600880546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b60008261195b8584611a68565b14949350505050565b604051630a85bd0160e11b81526000906001600160a01b0385169063150b7a02906119999033908990889088906004016121c1565b602060405180830381600087803b1580156119b357600080fd5b505af19250505080156119e3575060408051601f3d908101601f191682019092526119e0918101906120d7565b60015b611a3e573d808015611a11576040519150601f19603f3d011682016040523d82523d6000602084013e611a16565b606091505b508051611a36576040516368d2bf6b60e11b815260040160405180910390fd5b805181602001fd5b6001600160e01b031916630a85bd0160e11b149050949350505050565b61058c8383836001611ab5565b600081815b8451811015611aad57611a9982868381518110611a8c57611a8c6123b2565b6020026020010151611c5c565b915080611aa58161236b565b915050611a6d565b509392505050565b6000546001600160a01b038516611ade57604051622e076360e81b815260040160405180910390fd5b83611afc5760405163b562e8dd60e01b815260040160405180910390fd5b6001600160a01b038516600081815260056020908152604080832080546fffffffffffffffffffffffffffffffff1981166001600160401b038083168c018116918217600160401b67ffffffffffffffff1990941690921783900481168c01811690920217909155858452600490925290912080546001600160e01b031916909217600160a01b429092169190910217905580808501838015611ba857506001600160a01b0387163b15155b15611c1f575b60405182906001600160a01b038916906000906000805160206123f5833981519152908290a4611be76000888480600101955088611964565b611c04576040516368d2bf6b60e11b815260040160405180910390fd5b80821415611bae578260005414611c1a57600080fd5b611c53565b5b6040516001830192906001600160a01b038916906000906000805160206123f5833981519152908290a480821415611c20575b50600055611061565b6000818310611c78576000828152602084905260409020610cdb565b6000838152602083905260409020610cdb565b828054611c9790612330565b90600052602060002090601f016020900481019282611cb95760008555611cff565b82601f10611cd25782800160ff19823516178555611cff565b82800160010185558215611cff579182015b82811115611cff578235825591602001919060010190611ce4565b50611d0b929150611d0f565b5090565b5b80821115611d0b5760008155600101611d10565b80356001600160a01b0381168114611d3b57600080fd5b919050565b60008083601f840112611d5257600080fd5b5081356001600160401b03811115611d6957600080fd5b6020830191508360208260051b8501011115611d8457600080fd5b9250929050565b600060208284031215611d9d57600080fd5b610cdb82611d24565b60008060408385031215611db957600080fd5b611dc283611d24565b9150611dd060208401611d24565b90509250929050565b600080600060608486031215611dee57600080fd5b611df784611d24565b9250611e0560208501611d24565b9150604084013590509250925092565b60008060008060808587031215611e2b57600080fd5b611e3485611d24565b93506020611e43818701611d24565b93506040860135925060608601356001600160401b0380821115611e6657600080fd5b818801915088601f830112611e7a57600080fd5b813581811115611e8c57611e8c6123c8565b611e9e601f8201601f191685016122d1565b91508082528984828501011115611eb457600080fd5b808484018584013760008482840101525080935050505092959194509250565b60008060408385031215611ee757600080fd5b611ef083611d24565b915060208301358015158114611f0557600080fd5b809150509250929050565b60008060408385031215611f2357600080fd5b611f2c83611d24565b946020939093013593505050565b60008060208385031215611f4d57600080fd5b82356001600160401b03811115611f6357600080fd5b611f6f85828601611d40565b90969095509350505050565b60008060408385031215611f8e57600080fd5b82356001600160401b0380821115611fa557600080fd5b818501915085601f830112611fb957600080fd5b8135602082821115611fcd57611fcd6123c8565b8160051b9250611fde8184016122d1565b8281528181019085830185870184018b1015611ff957600080fd5b600096505b8487101561201c578035835260019690960195918301918301611ffe565b509997909101359750505050505050565b6000806020838503121561204057600080fd5b82356001600160401b038082111561205757600080fd5b818501915085601f83011261206b57600080fd5b81358181111561207a57600080fd5b8660208260061b850101111561208f57600080fd5b60209290920196919550909350505050565b6000602082840312156120b357600080fd5b5035919050565b6000602082840312156120cc57600080fd5b8135610cdb816123de565b6000602082840312156120e957600080fd5b8151610cdb816123de565b60006020828403121561210657600080fd5b813560048110610cdb57600080fd5b6000806020838503121561212857600080fd5b82356001600160401b038082111561213f57600080fd5b818501915085601f83011261215357600080fd5b81358181111561216257600080fd5b86602082850101111561208f57600080fd5b6000815180845260005b8181101561219a5760208185018101518683018201520161217e565b818111156121ac576000602083870101525b50601f01601f19169290920160200192915050565b6001600160a01b03858116825284166020820152604081018390526080606082018190526000906121f490830184612174565b9695505050505050565b602081016004831061222057634e487b7160e01b600052602160045260246000fd5b91905290565b602081526000610cdb6020830184612174565b60208082526026908201527f50554d41204e6974726f20546f6b656e3a204d696e7420537570706c7920457860408201526518d95959195960d21b606082015260800190565b60208082526032908201527f50554d41204e6974726f20546f6b656e3a20436f6e747261637420496e7465726040820152711858dd1a5bdb88139bdd08105b1b1bddd95960721b606082015260800190565b604051601f8201601f191681016001600160401b03811182821017156122f9576122f96123c8565b604052919050565b6000821982111561231457612314612386565b500190565b60008282101561232b5761232b612386565b500390565b600181811c9082168061234457607f821691505b6020821081141561236557634e487b7160e01b600052602260045260246000fd5b50919050565b600060001982141561237f5761237f612386565b5060010190565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052602160045260246000fd5b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052604160045260246000fd5b6001600160e01b03198116811461098057600080fdfeddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3efa26469706673582212202596abff26ed94d3b225686095152f6fce4d7e1750857d2625bdd496c738a70b64736f6c63430008070033

Deployed Bytecode Sourcemap

55405:5225:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25815:305;;;;;;:::i;:::-;;:::i;:::-;;;9049:14:1;;9042:22;9024:41;;9012:2;8997:18;25815:305:0;;;;;;;;60149:92;;;;;;:::i;:::-;;:::i;:::-;;29202:100;;;:::i;:::-;;;;;;;:::i;30705:204::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;8347:32:1;;;8329:51;;8317:2;8302:18;30705:204:0;8183:203:1;30268:371:0;;;;;;:::i;:::-;;:::i;56064:95::-;;;:::i;25064:303::-;24871:1;25318:12;25108:7;25302:13;:28;-1:-1:-1;;25302:46:0;25064:303;;;9222:25:1;;;9210:2;9195:18;25064:303:0;9076:177:1;58435:457:0;;;:::i;31562:170::-;;;;;;:::i;:::-;;:::i;56706:294::-;;;:::i;31803:185::-;;;;;;:::i;:::-;;:::i;59131:196::-;;;;;;:::i;:::-;;:::i;56293:134::-;;;;;;:::i;:::-;;:::i;59950:85::-;;;;;;:::i;:::-;;:::i;55490:32::-;;;;;-1:-1:-1;;;;;55490:32:0;;;59568:207;;;;;;:::i;:::-;;:::i;59339:219::-;;;;;;:::i;:::-;;:::i;29011:124::-;;;;;;:::i;:::-;;:::i;57008:224::-;;;;;;:::i;:::-;;:::i;26184:206::-;;;;;;:::i;:::-;;:::i;45753:103::-;;;:::i;59783:159::-;;;;;;:::i;:::-;;:::i;60043:94::-;;;;;;:::i;:::-;;:::i;56192:25::-;;;;;;45105:87;45178:6;;-1:-1:-1;;;;;45178:6:0;45105:87;;29371:104;;;:::i;30981:279::-;;;;;;:::i;:::-;;:::i;60455:170::-;;;:::i;57296:1127::-;;;;;;:::i;:::-;;:::i;32059:369::-;;;;;;:::i;:::-;;:::i;55573:94::-;;;;;;56166:19;;;;;;;;;;;;;;;;:::i;60249:198::-;;;;;;:::i;:::-;;:::i;55783:50::-;;;;;;:::i;:::-;;;;;;;;;;;;;;56516:182;;;;;;:::i;:::-;;:::i;31331:164::-;;;;;;:::i;:::-;-1:-1:-1;;;;;31452:25:0;;;31428:4;31452:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;31331:164;58900:223;;;;;;:::i;:::-;;:::i;46011:201::-;;;;;;:::i;:::-;;:::i;25815:305::-;25917:4;-1:-1:-1;;;;;;25954:40:0;;-1:-1:-1;;;25954:40:0;;:105;;-1:-1:-1;;;;;;;26011:48:0;;-1:-1:-1;;;26011:48:0;25954:105;:158;;;-1:-1:-1;;;;;;;;;;21295:40:0;;;26076:36;25934:178;25815:305;-1:-1:-1;;25815:305:0:o;60149:92::-;44991:13;:11;:13::i;:::-;60220::::1;:3;60226:7:::0;;60220:13:::1;:::i;:::-;;60149:92:::0;;:::o;29202:100::-;29256:13;29289:5;29282:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29202:100;:::o;30705:204::-;30773:7;30798:16;30806:7;30798;:16::i;:::-;30793:64;;30823:34;;-1:-1:-1;;;30823:34:0;;;;;;;;;;;30793:64;-1:-1:-1;30877:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;30877:24:0;;30705:204::o;30268:371::-;30341:13;30357:24;30373:7;30357:15;:24::i;:::-;30341:40;;30402:5;-1:-1:-1;;;;;30396:11:0;:2;-1:-1:-1;;;;;30396:11:0;;30392:48;;;30416:24;;-1:-1:-1;;;30416:24:0;;;;;;;;;;;30392:48;20187:10;-1:-1:-1;;;;;30457:21:0;;;;;;:63;;-1:-1:-1;30483:37:0;30500:5;20187:10;31331:164;:::i;30483:37::-;30482:38;30457:63;30453:138;;;30544:35;;-1:-1:-1;;;30544:35:0;;;;;;;;;;;30453:138;30603:28;30612:2;30616:7;30625:5;30603:8;:28::i;56064:95::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;58435:457::-;58486:10;58500:9;58486:23;58478:86;;;;-1:-1:-1;;;58478:86:0;;;;;;;:::i;:::-;;;;;;;;;58592:13;58583:5;;;;:22;;;;;;;;:::i;:::-;;58575:68;;;;-1:-1:-1;;;58575:68:0;;13945:2:1;58575:68:0;;;13927:21:1;13984:2;13964:18;;;13957:30;14023:34;14003:18;;;13996:62;-1:-1:-1;;;14074:18:1;;;14067:31;14115:19;;58575:68:0;13743:397:1;58575:68:0;58690:1;58662:25;58676:10;58662:13;:25::i;:::-;:29;58654:82;;;;-1:-1:-1;;;58654:82:0;;11948:2:1;58654:82:0;;;11930:21:1;11987:2;11967:18;;;11960:30;12026:34;12006:18;;;11999:62;-1:-1:-1;;;12077:18:1;;;12070:38;12125:19;;58654:82:0;11746:404:1;58654:82:0;55704:4;58755:10;;58768:1;58755:14;;;;:::i;:::-;:28;;58747:79;;;;-1:-1:-1;;;58747:79:0;;;;;;;:::i;:::-;58837:10;:12;;;:10;:12;;;:::i;:::-;;;;;;58860:24;58870:10;58882:1;58860:9;:24::i;:::-;58435:457::o;31562:170::-;31696:28;31706:4;31712:2;31716:7;31696:9;:28::i;56706:294::-;44991:13;:11;:13::i;:::-;56781:12:::1;56772:5;::::0;::::1;;:21;::::0;::::1;;;;;;:::i;:::-;;56764:62;;;::::0;-1:-1:-1;;;56764:62:0;;14347:2:1;56764:62:0::1;::::0;::::1;14329:21:1::0;14386:2;14366:18;;;14359:30;14425;14405:18;;;14398:58;14473:18;;56764:62:0::1;14145:352:1::0;56764:62:0::1;56842:16;56837:156;55704:4;56862:8;:19;56837:156;;;56913:17;56921:8;56913:7;:17::i;:::-;56910:72;;;56951:15;56957:8;56951:5;:15::i;:::-;56883:10:::0;::::1;::::0;::::1;:::i;:::-;;;;56837:156;;;;56706:294::o:0;31803:185::-;31941:39;31958:4;31964:2;31968:7;31941:39;;;;;;;;;;;;:16;:39::i;59131:196::-;44991:13;:11;:13::i;:::-;59219:9:::1;59214:106;59234:20:::0;;::::1;59214:106;;;59307:1;59276:14;:28;59291:9;;59301:1;59291:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;59276:28:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;59276:28:0;:32;59256:3;::::1;::::0;::::1;:::i;:::-;;;;59214:106;;56293:134:::0;44991:13;:11;:13::i;:::-;56381:17:::1;:38:::0;;-1:-1:-1;;;;;;56381:38:0::1;-1:-1:-1::0;;;;;56381:38:0;;;::::1;::::0;;;::::1;::::0;;56293:134::o;59950:85::-;44991:13;:11;:13::i;:::-;60013:5:::1;:14:::0;;60021:6;;60013:5;-1:-1:-1;;60013:14:0::1;::::0;60021:6;60013:14:::1;::::0;::::1;;;;;;:::i;:::-;;;;;;59950:85:::0;:::o;59568:207::-;44991:13;:11;:13::i;:::-;-1:-1:-1;;;;;59649:25:0;::::1;;::::0;;;:14:::1;:25;::::0;;;;;59641:86:::1;;;::::0;-1:-1:-1;;;59641:86:0;;10842:2:1;59641:86:0::1;::::0;::::1;10824:21:1::0;10881:2;10861:18;;;10854:30;10920:34;10900:18;;;10893:62;-1:-1:-1;;;10971:18:1;;;10964:41;11022:19;;59641:86:0::1;10640:407:1::0;59641:86:0::1;-1:-1:-1::0;;;;;59738:25:0::1;59766:1;59738:25:::0;;;:14:::1;:25;::::0;;;;:29;59568:207::o;59339:219::-;44991:13;:11;:13::i;:::-;-1:-1:-1;;;;;59433:24:0;::::1;;::::0;;;:14:::1;:24;::::0;;;;;:29;59425:80:::1;;;::::0;-1:-1:-1;;;59425:80:0;;13122:2:1;59425:80:0::1;::::0;::::1;13104:21:1::0;13161:2;13141:18;;;13134:30;13200:34;13180:18;;;13173:62;-1:-1:-1;;;13251:18:1;;;13244:36;13297:19;;59425:80:0::1;12920:402:1::0;59425:80:0::1;-1:-1:-1::0;;;;;59516:24:0;;::::1;;::::0;;;:14:::1;:24;::::0;;;;:34;59339:219::o;29011:124::-;29075:7;29102:20;29114:7;29102:11;:20::i;:::-;:25;;29011:124;-1:-1:-1;;29011:124:0:o;57008:224::-;44991:13;:11;:13::i;:::-;57094:12:::1;57085:5;::::0;::::1;;:21;::::0;::::1;;;;;;:::i;:::-;;57077:62;;;::::0;-1:-1:-1;;;57077:62:0;;14347:2:1;57077:62:0::1;::::0;::::1;14329:21:1::0;14386:2;14366:18;;;14359:30;14425;14405:18;;;14398:58;14473:18;;57077:62:0::1;14145:352:1::0;57077:62:0::1;57158:16;57166:7;57158;:16::i;:::-;57150:49;;;::::0;-1:-1:-1;;;57150:49:0;;11254:2:1;57150:49:0::1;::::0;::::1;11236:21:1::0;11293:2;11273:18;;;11266:30;-1:-1:-1;;;11312:18:1;;;11305:50;11372:18;;57150:49:0::1;11052:344:1::0;57150:49:0::1;57210:14;57216:7;57210:5;:14::i;26184:206::-:0;26248:7;-1:-1:-1;;;;;26272:19:0;;26268:60;;26300:28;;-1:-1:-1;;;26300:28:0;;;;;;;;;;;26268:60;-1:-1:-1;;;;;;26354:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;26354:27:0;;26184:206::o;45753:103::-;44991:13;:11;:13::i;:::-;45818:30:::1;45845:1;45818:18;:30::i;59783:159::-:0;59867:4;59891:43;59910:5;59917:10;;59929:4;59891:18;:43::i;:::-;59884:50;59783:159;-1:-1:-1;;;59783:159:0:o;60043:94::-;44991:13;:11;:13::i;:::-;60111:10:::1;:18:::0;60043:94::o;29371:104::-;29427:13;29460:7;29453:14;;;;;:::i;30981:279::-;-1:-1:-1;;;;;31072:24:0;;20187:10;31072:24;31068:54;;;31105:17;;-1:-1:-1;;;31105:17:0;;;;;;;;;;;31068:54;20187:10;31135:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;31135:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;31135:53:0;;;;;;;;;;31204:48;;9024:41:1;;;31135:42:0;;20187:10;31204:48;;8997:18:1;31204:48:0;;;;;;;30981:279;;:::o;60455:170::-;44991:13;:11;:13::i;:::-;60525:49:::1;::::0;60507:12:::1;::::0;60525:10:::1;::::0;60548:21:::1;::::0;60507:12;60525:49;60507:12;60525:49;60548:21;60525:10;:49:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60506:68;;;60589:7;60581:36;;;::::0;-1:-1:-1;;;60581:36:0;;11603:2:1;60581:36:0::1;::::0;::::1;11585:21:1::0;11642:2;11622:18;;;11615:30;-1:-1:-1;;;11661:18:1;;;11654:46;11717:18;;60581:36:0::1;11401:340:1::0;57296:1127:0;57366:10;57380:9;57366:23;57358:86;;;;-1:-1:-1;;;57358:86:0;;;;;;;:::i;:::-;57472:25;57463:5;;;;:34;;;;;;;;:::i;:::-;;57455:82;;;;-1:-1:-1;;;57455:82:0;;12357:2:1;57455:82:0;;;12339:21:1;12396:2;12376:18;;;12369:30;12435:34;12415:18;;;12408:62;-1:-1:-1;;;12486:18:1;;;12479:33;12529:19;;57455:82:0;12155:399:1;57455:82:0;57556:77;57575:6;;57556:77;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;57582:10:0;;57603:28;;-1:-1:-1;;57620:10:0;7888:2:1;7884:15;7880:53;57603:28:0;;;7868:66:1;57582:10:0;;-1:-1:-1;7950:12:1;;;-1:-1:-1;57603:28:0;;;;;;;;;;;;57593:39;;;;;;57556:18;:77::i;:::-;57548:103;;;;-1:-1:-1;;;57548:103:0;;15123:2:1;57548:103:0;;;15105:21:1;15162:2;15142:18;;;15135:30;-1:-1:-1;;;15181:18:1;;;15174:44;15235:18;;57548:103:0;14921:338:1;57548:103:0;57703:10;57662:23;57688:26;;;:14;:26;;;;;;;57748:25;;:13;:25::i;:::-;57725:48;-1:-1:-1;57784:26:0;57813:30;57725:48;57813:15;:30;:::i;:::-;57784:59;-1:-1:-1;57858:19:0;;57854:510;;57919:12;57901:15;:30;57893:39;;;;;;55704:4;57968:18;57955:10;;:31;;;;:::i;:::-;:45;;57947:96;;;;-1:-1:-1;;;57947:96:0;;;;;;;:::i;:::-;58072:18;58058:10;;:32;;;;;;;:::i;:::-;;;;-1:-1:-1;;58120:10:0;58134:1;58105:26;;;:14;:26;;;;;:30;57854:510;;;58191:1;58176:12;:16;58168:25;;;;;;55704:4;58216:10;;58229:1;58216:14;;;;:::i;:::-;:28;;58208:79;;;;-1:-1:-1;;;58208:79:0;;;;;;;:::i;:::-;-1:-1:-1;58339:10:0;:13;;58323:1;;58339:10;:13;;;:::i;:::-;;;;;;57854:510;58374:41;58384:10;58396:18;58374:9;:41::i;:::-;57347:1076;;;57296:1127;;:::o;32059:369::-;32226:28;32236:4;32242:2;32246:7;32226:9;:28::i;:::-;-1:-1:-1;;;;;32269:13:0;;12399:19;:23;;32269:76;;;;;32289:56;32320:4;32326:2;32330:7;32339:5;32289:30;:56::i;:::-;32288:57;32269:76;32265:156;;;32369:40;;-1:-1:-1;;;32369:40:0;;;;;;;;;;;32265:156;32059:369;;;;:::o;60249:198::-;60315:13;60349:17;60357:8;60349:7;:17::i;:::-;60341:77;;;;-1:-1:-1;;;60341:77:0;;13529:2:1;60341:77:0;;;13511:21:1;13568:2;13548:18;;;13541:30;13607:34;13587:18;;;13580:62;-1:-1:-1;;;13658:18:1;;;13651:45;13713:19;;60341:77:0;13327:411:1;60341:77:0;60436:3;60429:10;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60249:198;;;:::o;56516:182::-;56616:17;;-1:-1:-1;;;;;56616:17:0;56602:10;:31;56594:66;;;;-1:-1:-1;;;56594:66:0;;15466:2:1;56594:66:0;;;15448:21:1;15505:2;15485:18;;;15478:30;-1:-1:-1;;;15524:18:1;;;15517:52;15586:18;;56594:66:0;15264:346:1;58900:223:0;44991:13;:11;:13::i;:::-;58993:9:::1;58989:127;59008:20:::0;;::::1;58989:127;;;59085:9;;59095:1;59085:12;;;;;;;:::i;:::-;;;;;;:19;;;59049:14;:33;59064:9;;59074:1;59064:12;;;;;;;:::i;:::-;:17;::::0;::::1;:12;::::0;;::::1;;:17:::0;;::::1;::::0;-1:-1:-1;59064:17:0::1;:::i;:::-;-1:-1:-1::0;;;;;59049:33:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;59049:33:0;:55;59030:3;::::1;::::0;::::1;:::i;:::-;;;;58989:127;;46011:201:::0;44991:13;:11;:13::i;:::-;-1:-1:-1;;;;;46100:22:0;::::1;46092:73;;;::::0;-1:-1:-1;;;46092:73:0;;10028:2:1;46092:73:0::1;::::0;::::1;10010:21:1::0;10067:2;10047:18;;;10040:30;10106:34;10086:18;;;10079:62;-1:-1:-1;;;10157:18:1;;;10150:36;10203:19;;46092:73:0::1;9826:402:1::0;46092:73:0::1;46176:28;46195:8;46176:18;:28::i;45270:132::-:0;45178:6;;-1:-1:-1;;;;;45178:6:0;20187:10;45334:23;45326:68;;;;-1:-1:-1;;;45326:68:0;;12761:2:1;45326:68:0;;;12743:21:1;;;12780:18;;;12773:30;12839:34;12819:18;;;12812:62;12891:18;;45326:68:0;12559:356:1;32683:187:0;32740:4;32783:7;24871:1;32764:26;;:53;;;;;32804:13;;32794:7;:23;32764:53;:98;;;;-1:-1:-1;;32835:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;32835:27:0;;;;32834:28;;32683:187::o;40294:196::-;40409:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;40409:29:0;-1:-1:-1;;;;;40409:29:0;;;;;;;;;40454:28;;40409:24;;40454:28;;;;;;;40294:196;;;:::o;26472:207::-;26533:7;-1:-1:-1;;;;;26557:19:0;;26553:59;;26585:27;;-1:-1:-1;;;26585:27:0;;;;;;;;;;;26553:59;-1:-1:-1;;;;;;26638:19:0;;;;;:12;:19;;;;;:32;-1:-1:-1;;;26638:32:0;;-1:-1:-1;;;;;26638:32:0;;26472:207::o;32878:104::-;32947:27;32957:2;32961:8;32947:27;;;;;;;;;;;;:9;:27::i;:::-;32878:104;;:::o;35796:2112::-;35911:35;35949:20;35961:7;35949:11;:20::i;:::-;36024:18;;35911:58;;-1:-1:-1;35982:22:0;;-1:-1:-1;;;;;36008:34:0;20187:10;-1:-1:-1;;;;;36008:34:0;;:101;;;-1:-1:-1;36076:18:0;;36059:50;;20187:10;31331:164;:::i;36059:50::-;36008:154;;;-1:-1:-1;20187:10:0;36126:20;36138:7;36126:11;:20::i;:::-;-1:-1:-1;;;;;36126:36:0;;36008:154;35982:181;;36181:17;36176:66;;36207:35;;-1:-1:-1;;;36207:35:0;;;;;;;;;;;36176:66;36279:4;-1:-1:-1;;;;;36257:26:0;:13;:18;;;-1:-1:-1;;;;;36257:26:0;;36253:67;;36292:28;;-1:-1:-1;;;36292:28:0;;;;;;;;;;;36253:67;-1:-1:-1;;;;;36335:16:0;;36331:52;;36360:23;;-1:-1:-1;;;36360:23:0;;;;;;;;;;;36331:52;36504:49;36521:1;36525:7;36534:13;:18;;;36504:8;:49::i;:::-;-1:-1:-1;;;;;36849:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;36849:31:0;;;-1:-1:-1;;;;;36849:31:0;;;-1:-1:-1;;36849:31:0;;;;;;;36895:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;36895:29:0;;;;;;;;;;;36941:20;;;:11;:20;;;;;;:30;;-1:-1:-1;;;;;;36986:61:0;;;;-1:-1:-1;;;37031:15:0;36986:61;;;;;;;;;;;37321:11;;;37351:24;;;;;:29;37321:11;;37351:29;37347:445;;37576:13;;37562:11;:27;37558:219;;;37646:18;;;37614:24;;;:11;:24;;;;;;;;:50;;37729:28;;;;-1:-1:-1;;;;;37687:70:0;-1:-1:-1;;;37687:70:0;-1:-1:-1;;;;;;37687:70:0;;;-1:-1:-1;;;;;37614:50:0;;;37687:70;;;;;;;37558:219;36824:979;37839:7;37835:2;-1:-1:-1;;;;;37820:27:0;37829:4;-1:-1:-1;;;;;37820:27:0;-1:-1:-1;;;;;;;;;;;37820:27:0;;;;;;;;;37858:42;32059:369;38137:2039;38197:35;38235:20;38247:7;38235:11;:20::i;:::-;38197:58;-1:-1:-1;38398:49:0;38415:1;38419:7;38428:13;:18;;;38398:8;:49::i;:::-;38756:18;;-1:-1:-1;;;;;38743:32:0;;;;;;;:12;:32;;;;;;;;:45;;-1:-1:-1;;38743:45:0;;-1:-1:-1;;;;;38743:45:0;;;-1:-1:-1;;38743:45:0;;;;;;;38816:18;;38803:32;;;;;;;:50;;-1:-1:-1;;;;38803:50:0;;-1:-1:-1;;;38803:50:0;;;;;;-1:-1:-1;38803:50:0;;;;;;;;;;;;38980:18;;38952:20;;;:11;:20;;;;;;:46;;-1:-1:-1;;;38952:46:0;;;-1:-1:-1;;;;;;39013:61:0;;;;-1:-1:-1;;;39058:15:0;39013:61;;;;;;;;;;;-1:-1:-1;;;;39089:34:0;;;;;;;39393:11;;;39423:24;;;;;:29;39393:11;;39423:29;39419:445;;39648:13;;39634:11;:27;39630:219;;;39718:18;;;39686:24;;;:11;:24;;;;;;;;:50;;39801:28;;;;-1:-1:-1;;;;;39759:70:0;-1:-1:-1;;;39759:70:0;-1:-1:-1;;;;;;39759:70:0;;;-1:-1:-1;;;;;39686:50:0;;;39759:70;;;;;;;39630:219;-1:-1:-1;39901:18:0;;39892:49;;39933:7;;39929:1;;-1:-1:-1;;;;;39892:49:0;;;;-1:-1:-1;;;;;;;;;;;39892:49:0;39929:1;;39892:49;-1:-1:-1;;40143:12:0;:14;;;;;;38137:2039::o;27841:1108::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;27951:7:0;;24871:1;28000:23;;:47;;;;;28034:13;;28027:4;:20;28000:47;27996:886;;;28068:31;28102:17;;;:11;:17;;;;;;;;;28068:51;;;;;;;;;-1:-1:-1;;;;;28068:51:0;;;;-1:-1:-1;;;28068:51:0;;-1:-1:-1;;;;;28068:51:0;;;;;;;;-1:-1:-1;;;28068:51:0;;;;;;;;;;;;;;28138:729;;28188:14;;-1:-1:-1;;;;;28188:28:0;;28184:101;;28252:9;27841:1108;-1:-1:-1;;;27841:1108:0:o;28184:101::-;-1:-1:-1;;;28627:6:0;28672:17;;;;:11;:17;;;;;;;;;28660:29;;;;;;;;;-1:-1:-1;;;;;28660:29:0;;;;;-1:-1:-1;;;28660:29:0;;-1:-1:-1;;;;;28660:29:0;;;;;;;;-1:-1:-1;;;28660:29:0;;;;;;;;;;;;;28720:28;28716:109;;28788:9;27841:1108;-1:-1:-1;;;27841:1108:0:o;28716:109::-;28587:261;;;28049:833;27996:886;28910:31;;-1:-1:-1;;;28910:31:0;;;;;;;;;;;46372:191;46465:6;;;-1:-1:-1;;;;;46482:17:0;;;-1:-1:-1;;;;;;46482:17:0;;;;;;;46515:40;;46465:6;;;46482:17;46465:6;;46515:40;;46446:16;;46515:40;46435:128;46372:191;:::o;47793:190::-;47918:4;47971;47942:25;47955:5;47962:4;47942:12;:25::i;:::-;:33;;47793:190;-1:-1:-1;;;;47793:190:0:o;40982:667::-;41166:72;;-1:-1:-1;;;41166:72:0;;41145:4;;-1:-1:-1;;;;;41166:36:0;;;;;:72;;20187:10;;41217:4;;41223:7;;41232:5;;41166:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;41166:72:0;;;;;;;;-1:-1:-1;;41166:72:0;;;;;;;;;;;;:::i;:::-;;;41162:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;41400:13:0;;41396:235;;41446:40;;-1:-1:-1;;;41446:40:0;;;;;;;;;;;41396:235;41589:6;41583:13;41574:6;41570:2;41566:15;41559:38;41162:480;-1:-1:-1;;;;;;41285:55:0;-1:-1:-1;;;41285:55:0;;-1:-1:-1;40982:667:0;;;;;;:::o;33345:163::-;33468:32;33474:2;33478:8;33488:5;33495:4;33468:5;:32::i;48660:296::-;48743:7;48786:4;48743:7;48801:118;48825:5;:12;48821:1;:16;48801:118;;;48874:33;48884:12;48898:5;48904:1;48898:8;;;;;;;;:::i;:::-;;;;;;;48874:9;:33::i;:::-;48859:48;-1:-1:-1;48839:3:0;;;;:::i;:::-;;;;48801:118;;;-1:-1:-1;48936:12:0;48660:296;-1:-1:-1;;;48660:296:0:o;33767:1775::-;33906:20;33929:13;-1:-1:-1;;;;;33957:16:0;;33953:48;;33982:19;;-1:-1:-1;;;33982:19:0;;;;;;;;;;;33953:48;34016:13;34012:44;;34038:18;;-1:-1:-1;;;34038:18:0;;;;;;;;;;;34012:44;-1:-1:-1;;;;;34407:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;34466:49:0;;-1:-1:-1;;;;;34407:44:0;;;;;;;34466:49;;;-1:-1:-1;;;;;34407:44:0;;;;;;34466:49;;;;;;;;;;;;;;;;34532:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;34582:66:0;;;;-1:-1:-1;;;34632:15:0;34582:66;;;;;;;;;;34532:25;34729:23;;;34773:4;:23;;;;-1:-1:-1;;;;;;34781:13:0;;12399:19;:23;;34781:15;34769:641;;;34817:314;34848:38;;34873:12;;-1:-1:-1;;;;;34848:38:0;;;34865:1;;-1:-1:-1;;;;;;;;;;;34848:38:0;34865:1;;34848:38;34914:69;34953:1;34957:2;34961:14;;;;;;34977:5;34914:30;:69::i;:::-;34909:174;;35019:40;;-1:-1:-1;;;35019:40:0;;;;;;;;;;;34909:174;35126:3;35110:12;:19;;34817:314;;35212:12;35195:13;;:29;35191:43;;35226:8;;;35191:43;34769:641;;;35275:120;35306:40;;35331:14;;;;;-1:-1:-1;;;;;35306:40:0;;;35323:1;;-1:-1:-1;;;;;;;;;;;35306:40:0;35323:1;;35306:40;35390:3;35374:12;:19;;35275:120;;34769:641;-1:-1:-1;35424:13:0;:28;35474:60;32059:369;54867:149;54930:7;54961:1;54957;:5;:51;;55092:13;55186:15;;;55222:4;55215:15;;;55269:4;55253:21;;54957:51;;;55092:13;55186:15;;;55222:4;55215:15;;;55269:4;55253:21;;54965:20;55024:268;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:173:1;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:367::-;255:8;265:6;319:3;312:4;304:6;300:17;296:27;286:55;;337:1;334;327:12;286:55;-1:-1:-1;360:20:1;;-1:-1:-1;;;;;392:30:1;;389:50;;;435:1;432;425:12;389:50;472:4;464:6;460:17;448:29;;532:3;525:4;515:6;512:1;508:14;500:6;496:27;492:38;489:47;486:67;;;549:1;546;539:12;486:67;192:367;;;;;:::o;564:186::-;623:6;676:2;664:9;655:7;651:23;647:32;644:52;;;692:1;689;682:12;644:52;715:29;734:9;715:29;:::i;755:260::-;823:6;831;884:2;872:9;863:7;859:23;855:32;852:52;;;900:1;897;890:12;852:52;923:29;942:9;923:29;:::i;:::-;913:39;;971:38;1005:2;994:9;990:18;971:38;:::i;:::-;961:48;;755:260;;;;;:::o;1020:328::-;1097:6;1105;1113;1166:2;1154:9;1145:7;1141:23;1137:32;1134:52;;;1182:1;1179;1172:12;1134:52;1205:29;1224:9;1205:29;:::i;:::-;1195:39;;1253:38;1287:2;1276:9;1272:18;1253:38;:::i;:::-;1243:48;;1338:2;1327:9;1323:18;1310:32;1300:42;;1020:328;;;;;:::o;1353:980::-;1448:6;1456;1464;1472;1525:3;1513:9;1504:7;1500:23;1496:33;1493:53;;;1542:1;1539;1532:12;1493:53;1565:29;1584:9;1565:29;:::i;:::-;1555:39;;1613:2;1634:38;1668:2;1657:9;1653:18;1634:38;:::i;:::-;1624:48;;1719:2;1708:9;1704:18;1691:32;1681:42;;1774:2;1763:9;1759:18;1746:32;-1:-1:-1;;;;;1838:2:1;1830:6;1827:14;1824:34;;;1854:1;1851;1844:12;1824:34;1892:6;1881:9;1877:22;1867:32;;1937:7;1930:4;1926:2;1922:13;1918:27;1908:55;;1959:1;1956;1949:12;1908:55;1995:2;1982:16;2017:2;2013;2010:10;2007:36;;;2023:18;;:::i;:::-;2065:53;2108:2;2089:13;;-1:-1:-1;;2085:27:1;2081:36;;2065:53;:::i;:::-;2052:66;;2141:2;2134:5;2127:17;2181:7;2176:2;2171;2167;2163:11;2159:20;2156:33;2153:53;;;2202:1;2199;2192:12;2153:53;2257:2;2252;2248;2244:11;2239:2;2232:5;2228:14;2215:45;2301:1;2296:2;2291;2284:5;2280:14;2276:23;2269:34;;2322:5;2312:15;;;;;1353:980;;;;;;;:::o;2338:347::-;2403:6;2411;2464:2;2452:9;2443:7;2439:23;2435:32;2432:52;;;2480:1;2477;2470:12;2432:52;2503:29;2522:9;2503:29;:::i;:::-;2493:39;;2582:2;2571:9;2567:18;2554:32;2629:5;2622:13;2615:21;2608:5;2605:32;2595:60;;2651:1;2648;2641:12;2595:60;2674:5;2664:15;;;2338:347;;;;;:::o;2690:254::-;2758:6;2766;2819:2;2807:9;2798:7;2794:23;2790:32;2787:52;;;2835:1;2832;2825:12;2787:52;2858:29;2877:9;2858:29;:::i;:::-;2848:39;2934:2;2919:18;;;;2906:32;;-1:-1:-1;;;2690:254:1:o;2949:437::-;3035:6;3043;3096:2;3084:9;3075:7;3071:23;3067:32;3064:52;;;3112:1;3109;3102:12;3064:52;3152:9;3139:23;-1:-1:-1;;;;;3177:6:1;3174:30;3171:50;;;3217:1;3214;3207:12;3171:50;3256:70;3318:7;3309:6;3298:9;3294:22;3256:70;:::i;:::-;3345:8;;3230:96;;-1:-1:-1;2949:437:1;-1:-1:-1;;;;2949:437:1:o;3833:1027::-;3926:6;3934;3987:2;3975:9;3966:7;3962:23;3958:32;3955:52;;;4003:1;4000;3993:12;3955:52;4043:9;4030:23;-1:-1:-1;;;;;4113:2:1;4105:6;4102:14;4099:34;;;4129:1;4126;4119:12;4099:34;4167:6;4156:9;4152:22;4142:32;;4212:7;4205:4;4201:2;4197:13;4193:27;4183:55;;4234:1;4231;4224:12;4183:55;4270:2;4257:16;4292:4;4315:2;4311;4308:10;4305:36;;;4321:18;;:::i;:::-;4367:2;4364:1;4360:10;4350:20;;4390:28;4414:2;4410;4406:11;4390:28;:::i;:::-;4452:15;;;4483:12;;;;4515:11;;;4545;;;4541:20;;4538:33;-1:-1:-1;4535:53:1;;;4584:1;4581;4574:12;4535:53;4606:1;4597:10;;4616:163;4630:2;4627:1;4624:9;4616:163;;;4687:17;;4675:30;;4648:1;4641:9;;;;;4725:12;;;;4757;;4616:163;;;-1:-1:-1;4798:5:1;4835:18;;;;4822:32;;-1:-1:-1;;;;;;;3833:1027:1:o;4865:650::-;4986:6;4994;5047:2;5035:9;5026:7;5022:23;5018:32;5015:52;;;5063:1;5060;5053:12;5015:52;5103:9;5090:23;-1:-1:-1;;;;;5173:2:1;5165:6;5162:14;5159:34;;;5189:1;5186;5179:12;5159:34;5227:6;5216:9;5212:22;5202:32;;5272:7;5265:4;5261:2;5257:13;5253:27;5243:55;;5294:1;5291;5284:12;5243:55;5334:2;5321:16;5360:2;5352:6;5349:14;5346:34;;;5376:1;5373;5366:12;5346:34;5429:7;5424:2;5414:6;5411:1;5407:14;5403:2;5399:23;5395:32;5392:45;5389:65;;;5450:1;5447;5440:12;5389:65;5481:2;5473:11;;;;;5503:6;;-1:-1:-1;4865:650:1;;-1:-1:-1;;;;4865:650:1:o;5520:180::-;5579:6;5632:2;5620:9;5611:7;5607:23;5603:32;5600:52;;;5648:1;5645;5638:12;5600:52;-1:-1:-1;5671:23:1;;5520:180;-1:-1:-1;5520:180:1:o;5705:245::-;5763:6;5816:2;5804:9;5795:7;5791:23;5787:32;5784:52;;;5832:1;5829;5822:12;5784:52;5871:9;5858:23;5890:30;5914:5;5890:30;:::i;5955:249::-;6024:6;6077:2;6065:9;6056:7;6052:23;6048:32;6045:52;;;6093:1;6090;6083:12;6045:52;6125:9;6119:16;6144:30;6168:5;6144:30;:::i;6209:267::-;6279:6;6332:2;6320:9;6311:7;6307:23;6303:32;6300:52;;;6348:1;6345;6338:12;6300:52;6387:9;6374:23;6426:1;6419:5;6416:12;6406:40;;6442:1;6439;6432:12;6481:592;6552:6;6560;6613:2;6601:9;6592:7;6588:23;6584:32;6581:52;;;6629:1;6626;6619:12;6581:52;6669:9;6656:23;-1:-1:-1;;;;;6739:2:1;6731:6;6728:14;6725:34;;;6755:1;6752;6745:12;6725:34;6793:6;6782:9;6778:22;6768:32;;6838:7;6831:4;6827:2;6823:13;6819:27;6809:55;;6860:1;6857;6850:12;6809:55;6900:2;6887:16;6926:2;6918:6;6915:14;6912:34;;;6942:1;6939;6932:12;6912:34;6987:7;6982:2;6973:6;6969:2;6965:15;6961:24;6958:37;6955:57;;;7008:1;7005;6998:12;7263:471;7304:3;7342:5;7336:12;7369:6;7364:3;7357:19;7394:1;7404:162;7418:6;7415:1;7412:13;7404:162;;;7480:4;7536:13;;;7532:22;;7526:29;7508:11;;;7504:20;;7497:59;7433:12;7404:162;;;7584:6;7581:1;7578:13;7575:87;;;7650:1;7643:4;7634:6;7629:3;7625:16;7621:27;7614:38;7575:87;-1:-1:-1;7716:2:1;7695:15;-1:-1:-1;;7691:29:1;7682:39;;;;7723:4;7678:50;;7263:471;-1:-1:-1;;7263:471:1:o;8391:488::-;-1:-1:-1;;;;;8660:15:1;;;8642:34;;8712:15;;8707:2;8692:18;;8685:43;8759:2;8744:18;;8737:34;;;8807:3;8802:2;8787:18;;8780:31;;;8585:4;;8828:45;;8853:19;;8845:6;8828:45;:::i;:::-;8820:53;8391:488;-1:-1:-1;;;;;;8391:488:1:o;9258:339::-;9401:2;9386:18;;9434:1;9423:13;;9413:144;;9479:10;9474:3;9470:20;9467:1;9460:31;9514:4;9511:1;9504:15;9542:4;9539:1;9532:15;9413:144;9566:25;;;9258:339;:::o;9602:219::-;9751:2;9740:9;9733:21;9714:4;9771:44;9811:2;9800:9;9796:18;9788:6;9771:44;:::i;10233:402::-;10435:2;10417:21;;;10474:2;10454:18;;;10447:30;10513:34;10508:2;10493:18;;10486:62;-1:-1:-1;;;10579:2:1;10564:18;;10557:36;10625:3;10610:19;;10233:402::o;14502:414::-;14704:2;14686:21;;;14743:2;14723:18;;;14716:30;14782:34;14777:2;14762:18;;14755:62;-1:-1:-1;;;14848:2:1;14833:18;;14826:48;14906:3;14891:19;;14502:414::o;15797:275::-;15868:2;15862:9;15933:2;15914:13;;-1:-1:-1;;15910:27:1;15898:40;;-1:-1:-1;;;;;15953:34:1;;15989:22;;;15950:62;15947:88;;;16015:18;;:::i;:::-;16051:2;16044:22;15797:275;;-1:-1:-1;15797:275:1:o;16077:128::-;16117:3;16148:1;16144:6;16141:1;16138:13;16135:39;;;16154:18;;:::i;:::-;-1:-1:-1;16190:9:1;;16077:128::o;16210:125::-;16250:4;16278:1;16275;16272:8;16269:34;;;16283:18;;:::i;:::-;-1:-1:-1;16320:9:1;;16210:125::o;16340:380::-;16419:1;16415:12;;;;16462;;;16483:61;;16537:4;16529:6;16525:17;16515:27;;16483:61;16590:2;16582:6;16579:14;16559:18;16556:38;16553:161;;;16636:10;16631:3;16627:20;16624:1;16617:31;16671:4;16668:1;16661:15;16699:4;16696:1;16689:15;16553:161;;16340:380;;;:::o;16725:135::-;16764:3;-1:-1:-1;;16785:17:1;;16782:43;;;16805:18;;:::i;:::-;-1:-1:-1;16852:1:1;16841:13;;16725:135::o;16865:127::-;16926:10;16921:3;16917:20;16914:1;16907:31;16957:4;16954:1;16947:15;16981:4;16978:1;16971:15;16997:127;17058:10;17053:3;17049:20;17046:1;17039:31;17089:4;17086:1;17079:15;17113:4;17110:1;17103:15;17129:127;17190:10;17185:3;17181:20;17178:1;17171:31;17221:4;17218:1;17211:15;17245:4;17242:1;17235:15;17261:127;17322:10;17317:3;17313:20;17310:1;17303:31;17353:4;17350:1;17343:15;17377:4;17374:1;17367:15;17393:131;-1:-1:-1;;;;;;17467:32:1;;17457:43;;17447:71;;17514:1;17511;17504:12

Swarm Source

ipfs://2596abff26ed94d3b225686095152f6fce4d7e1750857d2625bdd496c738a70b

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