Token

Teahouse HighTable OG (HTOG)

ERC-721

Overview

Max Total Supply

77 HTOG

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x5992538ac9dd92a9e864368c0ee7e23c134f705c

Filtered by Token Holder

0xF8724AE18936A4d510702F09c0ab525D8af3f2A1

cryptocamel.eth

Balance

1 HTOG

0xf8724ae18936a4d510702f09c0ab525d8af3f2a1

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.

Contract Source Code Verified (Exact Match)

Contract Name:

HightableOG

Compiler Version

v0.8.13+commit.abaa5c0e

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, BSL 1.1 license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-04-13
*/

// SPDX-License-Identifier: BUSL-1.1
// File: contracts/IPFSConvert.sol

// contracts/IPFSConvert.sol


pragma solidity ^0.8.0;

/// @title Hightable OG NFT
/// @author Teahouse Finance
library IPFSConvert {

    bytes constant private CODE_STRING = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
    bytes constant private CIDV0HEAD = "\x00\x04\x28\x0b\x12\x17\x09\x28\x31\x00\x12\x04\x28\x20\x25\x25\x22\x31\x1b\x1d\x39\x29\x09\x26\x1b\x29\x0b\x02\x0a\x18\x25\x22\x24\x1b\x39\x2c\x1d\x39\x07\x06\x29\x25\x13\x15\x2c\x17";

    /**
     * @dev This function converts an 256 bits hash value into IPFS CIDv0 hash string.
     * @param _cidv0 256 bits hash value (not including the 0x12 0x20 signature)
     * @return IPFS CIDv0 hash string (Qm...)
     */
    function cidv0FromBytes32(bytes32 _cidv0) public pure returns (string memory) {
        unchecked {
            // convert to base58
            bytes memory result = new bytes(46);        // 46 is the longest possible base58 result from CIDv0
            uint256 resultLen = 45;
            uint256 number = uint256(_cidv0);
            while(number > 0) {
                uint256 rem = number % 58;
                result[resultLen] = bytes1(uint8(rem));
                resultLen--;
                number = number / 58;
            }

            // add 0x1220 in front of _cidv0
            uint256 i;
            for (i = 0; i < 46; i++) {
                uint8 r = uint8(result[45 - i]) + uint8(CIDV0HEAD[i]);
                if (r >= 58) {
                    result[45 - i] = bytes1(r - 58);
                    result[45 - i - 1] = bytes1(uint8(result[45 - i - 1]) + 1);
                }
                else {
                    result[45 - i] = bytes1(r);
                }
            }

            // convert to characters
            for (i = 0; i < 46; i++) {
                result[i] = CODE_STRING[uint8(result[i])];
            }

            return string(result);
        }
    }
}

// File: @openzeppelin/contracts/utils/Address.sol


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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts v4.4.1 (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 `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


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

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


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

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts v4.4.1 (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`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

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

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol


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

pragma solidity ^0.8.0;


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

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

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

// File: @openzeppelin/contracts/utils/Strings.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

// File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

        return (signer, RecoverError.NoError);
    }

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

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

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

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

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


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

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// File: @openzeppelin/contracts/utils/Context.sol


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

pragma solidity ^0.8.0;

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

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

// File: erc721a/contracts/ERC721A.sol


// Creator: Chiru Labs

pragma solidity ^0.8.4;








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

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Compiler will pack this into a single 256bit word.
    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

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

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

    // The number of tokens burned.
    uint256 internal _burnCounter;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned. See _ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

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

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

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

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

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

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

    /**
     * Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        // Counter underflow is impossible as _currentIndex does not decrement,
        // and it is initialized to _startTokenId()
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return uint256(_addressData[owner].balance);
    }

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

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

    /**
     * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        return _addressData[owner].aux;
    }

    /**
     * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        _addressData[owner].aux = aux;
    }

    /**
     * Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around in the collection over time.
     */
    function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr && curr < _currentIndex) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (!ownership.burned) {
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                    // Invariant:
                    // There will always be an ownership that has an address and is not burned
                    // before an ownership that does not have an address and is not burned.
                    // Hence, curr will not underflow.
                    while (true) {
                        curr--;
                        ownership = _ownerships[curr];
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                    }
                }
            }
        }
        revert OwnerQueryForNonexistentToken();
    }

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

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

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

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

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

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

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

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

        _approve(to, tokenId, owner);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

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

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfers(from, to, tokenId, 1);

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

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

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

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

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

    /**
     * @dev This is equivalent to _burn(tokenId, false)
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

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

        address from = prevOwnership.addr;

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

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

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

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

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

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

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

        emit Transfer(from, address(0), tokenId);
        _afterTokenTransfers(from, address(0), tokenId, 1);

        // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
        unchecked {
            _burnCounter++;
        }
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(
        address to,
        uint256 tokenId,
        address owner
    ) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

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

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
     * minting.
     * And also called after one token has been burned.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}

// File: @openzeppelin/contracts/access/Ownable.sol


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

// File: contracts/HightableOG.sol


pragma solidity ^0.8.0;







error ReachedMaxSupply();
error TransactionExpired();
error ExceedMaxAllowedMintAmount();
error IncorrectSignature();
error InsufficientPayments();
error TokenRevealQueryForNonexistentToken();
error NotRevealer();
error TokenIndexOutOfBounds();
error UnableToWithdrawFund();


/// @title Hightable OG NFT
/// @author Teahouse Finance
contract HightableOG is ERC721A, Ownable, ReentrancyGuard {
    using ECDSA for bytes32;

    address public whitelistSigner;
    address public revealer;
    uint256 public price = 5.5 ether;
    uint256 public maxCollection;

    string public unrevealURI;

    mapping(uint256 => bytes32) private tokenBaseURIHash;


    /// @param _name Name of the NFT
    /// @param _symbol Symbol of the NFT
    /// @param _maxCollection Maximum allowed number of tokens
    constructor(
        string memory _name,
        string memory _symbol,
        uint256 _maxCollection          // total supply
    ) ERC721A(_name, _symbol) {
        maxCollection = _maxCollection;
    }


    /// @notice Set token minting price
    /// @param _newPrice New price in wei
    /// @dev Only owner can do this
    function setPrice(uint256 _newPrice) external onlyOwner {
        price = _newPrice;
    }


    /// @notice Set whitelist minting signer address
    /// @param _newWhitelistSigner New signer address
    /// @dev Only owner can do this
    function setWhitelistSigner(address _newWhitelistSigner) external onlyOwner {
        whitelistSigner = _newWhitelistSigner;
    }


    /// @notice Set revealer address
    /// @param _newRevealer New revealer address
    /// @dev Only owner can do this
    function setRevealer(address _newRevealer) external onlyOwner {
        revealer = _newRevealer;
    }


    /// @notice Set token URI for unrevealed tokens
    /// @param _newURI New token URI
    /// @dev Only owner can do this
    function setUnrevealURI(string calldata _newURI) external onlyOwner {
        unrevealURI = _newURI;
    }


    function isAuthorized(address _sender, uint32 _allowAmount, uint64 _expireTime, bytes memory _signature) private view returns (bool) {
        bytes32 hashMsg = keccak256(abi.encodePacked(_sender, _allowAmount, _expireTime));
        bytes32 ethHashMessage = hashMsg.toEthSignedMessageHash();

        return ethHashMessage.recover(_signature) == whitelistSigner;
    }


    /// @notice Whitelist minting
    /// @param _amount Number of tokens to mint
    /// @param _allowAmount Allowed amount of tokens
    /// @param _expireTime Expiry time
    /// @param _signature The signature signed by the signer address
    /// @dev The caller must obtain a valid signature signed by the signer address from the server
    /// @dev and pays for the correct price to mint
    /// @dev The resulting token is sent to the caller's address
    function mint(uint32 _amount, uint32 _allowAmount, uint64 _expireTime, bytes calldata _signature) external payable {
        if (totalSupply() + _amount > maxCollection) revert ReachedMaxSupply();
        if (block.timestamp > _expireTime) revert TransactionExpired();
        if (_numberMinted(msg.sender) + _amount > _allowAmount) revert ExceedMaxAllowedMintAmount();
        if (!isAuthorized(msg.sender, _allowAmount, _expireTime, _signature)) revert IncorrectSignature();

        uint256 finalPrice = price * _amount;
        if (msg.value < finalPrice) revert InsufficientPayments();
        
        _safeMint(msg.sender, _amount);
    }


    /// @notice Developer minting
    /// @param _amount Number of tokens to mint
    /// @param _to Address to send the tokens to
    /// @dev Only owner can do this
    function devMint(uint256 _amount, address _to) external onlyOwner {
        if (totalSupply() + _amount > maxCollection) revert ReachedMaxSupply();

        _safeMint(_to, _amount);
    }


    /// @notice Reveal the token
    /// @param _tokenId TokenId to reveal
    /// @param _tokenBaseURIHash IPFS hash of the metadata for this token
    /// @dev Only revealer can do this
    function reveal(uint256 _tokenId, bytes32 _tokenBaseURIHash) public onlyRevealer {
        tokenBaseURIHash[_tokenId] = _tokenBaseURIHash;
    }


    /// @notice Returns token URI of a token
    /// @param _tokenId Token Id
    /// @return uri Token URI
    function tokenURI(uint256 _tokenId) public view virtual override returns (string memory uri) {
	    if (!_exists(_tokenId)) revert URIQueryForNonexistentToken();
        
        if (tokenBaseURIHash[_tokenId] == 0) {
            return unrevealURI;
        }
        else {
            bytes32 hash = tokenBaseURIHash[_tokenId];
            return string(abi.encodePacked("ipfs://", IPFSConvert.cidv0FromBytes32(hash)));
        }
	}


    /// @notice Returns the number of all minted tokens
    /// @return minted Number of all minted tokens
    function totalMinted() external view returns (uint256 minted) {
        return _totalMinted();
    }


    /// @notice Returns the number of all minted tokens from an address
    /// @param _minter Minter address
    /// @return minted Number of all minted tokens from the minter
    function numberMinted(address _minter) external view returns (uint256 minted) {
        return _numberMinted(_minter);
    }


    /// @notice Returns all tokenIds owned by an address
    /// @param _addr The address
    /// @param _startId starting tokenId
    /// @param _endId ending tokenId (inclusive)
    /// @return tokenIds Array of all tokenIds owned by the address
    /// @return endTokenId ending tokenId
    function ownedTokens(address _addr, uint256 _startId, uint256 _endId) external view returns (uint256[] memory tokenIds, uint256 endTokenId) {
        if (_endId == 0) {
            _endId = _currentIndex - 1;
        }

        if (_startId < _startTokenId() || _endId >= _currentIndex) revert TokenIndexOutOfBounds();

        uint256 i;
        uint256 balance = balanceOf(_addr);
        if (balance == 0) {
            return (new uint256[](0), _endId + 1);
        }

        if (balance > 256) {
            balance = 256;
        }

        uint256[] memory results = new uint256[](balance);
        uint256 idx = 0;
        
        address owner = ownerOf(_startId);
        for (i = _startId; i <= _endId; i++) {
            if (_ownerships[i].addr != address(0)) {
                owner = _ownerships[i].addr;
            }

            if (!_ownerships[i].burned && owner == _addr) {
                results[idx] = i;
                idx++;

                if (idx == balance) {
                    if (balance == balanceOf(_addr)) {
                        return (results, _endId + 1);
                    }
                    else {
                        return (results, i + 1);
                    }
                }
            }
        }

        uint256[] memory partialResults = new uint256[](idx);
        for (i = 0; i < idx; i++) {
            partialResults[i] = results[i];
        }        

        return (partialResults, _endId + 1);
    }


    /// @notice Withdraw funds in the NFT
    /// @param _to The address to send the funds to
    /// @dev Only owner can do this
    function withdraw(address payable _to) external payable onlyOwner nonReentrant {
        (bool success, ) = _to.call{value: address(this).balance}("");
        if (!success) revert UnableToWithdrawFund();
	}


    function _startTokenId() override internal view virtual returns (uint256) {
        // the starting token Id
        return 1;
    }


    modifier onlyRevealer {
        if(msg.sender != revealer) revert NotRevealer();
        _;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"uint256","name":"_maxCollection","type":"uint256"}],"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":"ExceedMaxAllowedMintAmount","type":"error"},{"inputs":[],"name":"IncorrectSignature","type":"error"},{"inputs":[],"name":"InsufficientPayments","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"NotRevealer","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ReachedMaxSupply","type":"error"},{"inputs":[],"name":"TokenIndexOutOfBounds","type":"error"},{"inputs":[],"name":"TransactionExpired","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"UnableToWithdrawFund","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_to","type":"address"}],"name":"devMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxCollection","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"_amount","type":"uint32"},{"internalType":"uint32","name":"_allowAmount","type":"uint32"},{"internalType":"uint64","name":"_expireTime","type":"uint64"},{"internalType":"bytes","name":"_signature","type":"bytes"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_minter","type":"address"}],"name":"numberMinted","outputs":[{"internalType":"uint256","name":"minted","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"},{"internalType":"uint256","name":"_startId","type":"uint256"},{"internalType":"uint256","name":"_endId","type":"uint256"}],"name":"ownedTokens","outputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"uint256","name":"endTokenId","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"bytes32","name":"_tokenBaseURIHash","type":"bytes32"}],"name":"reveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newPrice","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newRevealer","type":"address"}],"name":"setRevealer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newURI","type":"string"}],"name":"setUnrevealURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newWhitelistSigner","type":"address"}],"name":"setWhitelistSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"uri","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalMinted","outputs":[{"internalType":"uint256","name":"minted","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unrevealURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistSigner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"_to","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

0x6080604052600436106101ee5760003560e01c8063715018a61161010d578063a2309ff8116100a0578063d33814381161006f578063d338143814610561578063dc33e68114610581578063e985e9c5146105a1578063ef81b4d4146105ea578063f2fde38b1461060a57600080fd5b8063a2309ff8146104e8578063b88d4fde14610501578063c17c3fe314610521578063c87b56dd1461054157600080fd5b806396cf73cf116100dc57806396cf73cf1461047f57806397bc411c14610492578063a035b1fe146104b2578063a22cb465146104c857600080fd5b8063715018a6146104175780638da5cb5b1461042c57806391b7f5ed1461044a57806395d89b411461046a57600080fd5b80632d1a12f61161018557806349a0a50e1161015457806349a0a50e1461039657806351cff8d9146103c45780636352211e146103d757806370a08231146103f757600080fd5b80632d1a12f614610320578063390a5b9a146103405780634036778f1461035657806342842e0e1461037657600080fd5b806318160ddd116101c157806318160ddd146102a457806320b55a2d146102cb5780632126ea81146102eb57806323b872dd1461030057600080fd5b806301ffc9a7146101f357806306fdde0314610228578063081812fc1461024a578063095ea7b314610282575b600080fd5b3480156101ff57600080fd5b5061021361020e366004611f06565b61062a565b60405190151581526020015b60405180910390f35b34801561023457600080fd5b5061023d61067c565b60405161021f9190611f82565b34801561025657600080fd5b5061026a610265366004611f95565b61070e565b6040516001600160a01b03909116815260200161021f565b34801561028e57600080fd5b506102a261029d366004611fc3565b610752565b005b3480156102b057600080fd5b5060015460005403600019015b60405190815260200161021f565b3480156102d757600080fd5b50600b5461026a906001600160a01b031681565b3480156102f757600080fd5b5061023d6107df565b34801561030c57600080fd5b506102a261031b366004611fef565b61086d565b34801561032c57600080fd5b506102a261033b366004612030565b610878565b34801561034c57600080fd5b506102bd600d5481565b34801561036257600080fd5b506102a2610371366004612060565b6108f3565b34801561038257600080fd5b506102a2610391366004611fef565b610930565b3480156103a257600080fd5b506103b66103b1366004612082565b61094b565b60405161021f9291906120b7565b6102a26103d23660046120ff565b610be8565b3480156103e357600080fd5b5061026a6103f2366004611f95565b610ce4565b34801561040357600080fd5b506102bd6104123660046120ff565b610cf6565b34801561042357600080fd5b506102a2610d44565b34801561043857600080fd5b506008546001600160a01b031661026a565b34801561045657600080fd5b506102a2610465366004611f95565b610d7a565b34801561047657600080fd5b5061023d610da9565b6102a261048d366004612171565b610db8565b34801561049e57600080fd5b506102a26104ad3660046121f1565b610f26565b3480156104be57600080fd5b506102bd600c5481565b3480156104d457600080fd5b506102a26104e3366004612232565b610f5c565b3480156104f457600080fd5b50600054600019016102bd565b34801561050d57600080fd5b506102a261051c3660046122d2565b610ff1565b34801561052d57600080fd5b506102a261053c3660046120ff565b611042565b34801561054d57600080fd5b5061023d61055c366004611f95565b61108e565b34801561056d57600080fd5b506102a261057c3660046120ff565b611211565b34801561058d57600080fd5b506102bd61059c3660046120ff565b61125d565b3480156105ad57600080fd5b506102136105bc366004612380565b6001600160a01b03918216600090815260076020908152604080832093909416825291909152205460ff1690565b3480156105f657600080fd5b50600a5461026a906001600160a01b031681565b34801561061657600080fd5b506102a26106253660046120ff565b61128b565b60006001600160e01b031982166380ac58cd60e01b148061065b57506001600160e01b03198216635b5e139f60e01b145b8061067657506301ffc9a760e01b6001600160e01b03198316145b92915050565b60606002805461068b906123ae565b80601f01602080910402602001604051908101604052809291908181526020018280546106b7906123ae565b80156107045780601f106106d957610100808354040283529160200191610704565b820191906000526020600020905b8154815290600101906020018083116106e757829003601f168201915b5050505050905090565b600061071982611326565b610736576040516333d1c03960e21b815260040160405180910390fd5b506000908152600660205260409020546001600160a01b031690565b600061075d82610ce4565b9050806001600160a01b0316836001600160a01b0316036107915760405163250fdee360e21b815260040160405180910390fd5b336001600160a01b038216148015906107b157506107af81336105bc565b155b156107cf576040516367d9dca160e11b815260040160405180910390fd5b6107da83838361135f565b505050565b600e80546107ec906123ae565b80601f0160208091040260200160405190810160405280929190818152602001828054610818906123ae565b80156108655780601f1061083a57610100808354040283529160200191610865565b820191906000526020600020905b81548152906001019060200180831161084857829003601f168201915b505050505081565b6107da8383836113bb565b6008546001600160a01b031633146108ab5760405162461bcd60e51b81526004016108a2906123e8565b60405180910390fd5b600d5460015460005484919003600019016108c69190612433565b11156108e55760405163794bb39b60e01b815260040160405180910390fd5b6108ef81836115a9565b5050565b600b546001600160a01b0316331461091e5760405163572b2f3160e01b815260040160405180910390fd5b6000918252600f602052604090912055565b6107da83838360405180602001604052806000815250610ff1565b6060600082600003610969576001600054610966919061244b565b92505b600184108061097a57506000548310155b15610998576040516329c8c00760e21b815260040160405180910390fd5b6000806109a487610cf6565b9050806000036109d3576040805160008152602081019091526109c8866001612433565b935093505050610be0565b6101008111156109e257506101005b6000816001600160401b038111156109fc576109fc612265565b604051908082528060200260200182016040528015610a25578160200160208202803683370190505b509050600080610a3489610ce4565b90508894505b878511610b2d576000858152600460205260409020546001600160a01b031615610a7857506000848152600460205260409020546001600160a01b03165b600085815260046020526040902054600160e01b900460ff16158015610aaf5750896001600160a01b0316816001600160a01b0316145b15610b1b5784838381518110610ac757610ac7612462565b602090810291909101015281610adc81612478565b925050838203610b1b57610aef8a610cf6565b8403610b0f5782610b01896001612433565b965096505050505050610be0565b82610b01866001612433565b84610b2581612478565b955050610a3a565b6000826001600160401b03811115610b4757610b47612265565b604051908082528060200260200182016040528015610b70578160200160208202803683370190505b509050600095505b82861015610bc957838681518110610b9257610b92612462565b6020026020010151818781518110610bac57610bac612462565b602090810291909101015285610bc181612478565b965050610b78565b80610bd58a6001612433565b975097505050505050505b935093915050565b6008546001600160a01b03163314610c125760405162461bcd60e51b81526004016108a2906123e8565b600260095403610c645760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c0060448201526064016108a2565b60026009556040516000906001600160a01b0383169047908381818185875af1925050503d8060008114610cb4576040519150601f19603f3d011682016040523d82523d6000602084013e610cb9565b606091505b5050905080610cdb57604051634abd53ef60e11b815260040160405180910390fd5b50506001600955565b6000610cef826115c3565b5192915050565b60006001600160a01b038216610d1f576040516323d3ad8160e21b815260040160405180910390fd5b506001600160a01b03166000908152600560205260409020546001600160401b031690565b6008546001600160a01b03163314610d6e5760405162461bcd60e51b81526004016108a2906123e8565b610d7860006116ea565b565b6008546001600160a01b03163314610da45760405162461bcd60e51b81526004016108a2906123e8565b600c55565b60606003805461068b906123ae565b600d5460015460005463ffffffff881691900360001901610dd99190612433565b1115610df85760405163794bb39b60e01b815260040160405180910390fd5b826001600160401b0316421115610e22576040516338e5e54b60e21b815260040160405180910390fd5b3360009081526005602052604090205463ffffffff85811691610e5791881690600160401b90046001600160401b0316612433565b1115610e7657604051635c81808d60e11b815260040160405180910390fd5b610eb833858585858080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525061173c92505050565b610ed55760405163c1606c2f60e01b815260040160405180910390fd5b60008563ffffffff16600c54610eeb9190612491565b905080341015610f0e5760405163fa47be2b60e01b815260040160405180910390fd5b610f1e338763ffffffff166115a9565b505050505050565b6008546001600160a01b03163314610f505760405162461bcd60e51b81526004016108a2906123e8565b6107da600e8383611e57565b336001600160a01b03831603610f855760405163b06307db60e01b815260040160405180910390fd5b3360008181526007602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b610ffc8484846113bb565b6001600160a01b0383163b1515801561101e575061101c84848484611828565b155b1561103c576040516368d2bf6b60e11b815260040160405180910390fd5b50505050565b6008546001600160a01b0316331461106c5760405162461bcd60e51b81526004016108a2906123e8565b600b80546001600160a01b0319166001600160a01b0392909216919091179055565b606061109982611326565b6110b657604051630a14c4b560e41b815260040160405180910390fd5b6000828152600f6020526040812054900361115d57600e80546110d8906123ae565b80601f0160208091040260200160405190810160405280929190818152602001828054611104906123ae565b80156111515780601f1061112657610100808354040283529160200191611151565b820191906000526020600020905b81548152906001019060200180831161113457829003601f168201915b50505050509050919050565b6000828152600f602052604090819020549051638614c2c360e01b8152600481018290527374c56aedc2362629e72a777750f0c6bde0b2ec8290638614c2c390602401600060405180830381865af41580156111bd573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526111e591908101906124b0565b6040516020016111f59190612526565b604051602081830303815290604052915050919050565b919050565b6008546001600160a01b0316331461123b5760405162461bcd60e51b81526004016108a2906123e8565b600a80546001600160a01b0319166001600160a01b0392909216919091179055565b6001600160a01b038116600090815260056020526040812054600160401b90046001600160401b0316610676565b6008546001600160a01b031633146112b55760405162461bcd60e51b81526004016108a2906123e8565b6001600160a01b03811661131a5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016108a2565b611323816116ea565b50565b60008160011115801561133a575060005482105b8015610676575050600090815260046020526040902054600160e01b900460ff161590565b60008281526006602052604080822080546001600160a01b0319166001600160a01b0387811691821790925591518593918516917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591a4505050565b60006113c6826115c3565b9050836001600160a01b031681600001516001600160a01b0316146113fd5760405162a1148160e81b815260040160405180910390fd5b6000336001600160a01b038616148061141b575061141b85336105bc565b8061143657503361142b8461070e565b6001600160a01b0316145b90508061145657604051632ce44b5f60e11b815260040160405180910390fd5b6001600160a01b03841661147d57604051633a954ecd60e21b815260040160405180910390fd5b6114896000848761135f565b6001600160a01b038581166000908152600560209081526040808320805467ffffffffffffffff198082166001600160401b0392831660001901831617909255898616808652838620805493841693831660019081018416949094179055898652600490945282852080546001600160e01b031916909417600160a01b4290921691909102178355870180845292208054919390911661155d57600054821461155d57805460208601516001600160401b0316600160a01b026001600160e01b03199091166001600160a01b038a16171781555b50505082846001600160a01b0316866001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a45b5050505050565b6108ef828260405180602001604052806000815250611910565b604080516060810182526000808252602082018190529181019190915281806001111580156115f3575060005481105b156116d157600081815260046020908152604091829020825160608101845290546001600160a01b0381168252600160a01b81046001600160401b031692820192909252600160e01b90910460ff161515918101829052906116cf5780516001600160a01b031615611666579392505050565b5060001901600081815260046020908152604091829020825160608101845290546001600160a01b038116808352600160a01b82046001600160401b031693830193909352600160e01b900460ff16151592810192909252156116ca579392505050565b611666565b505b604051636f96cda160e11b815260040160405180910390fd5b600880546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b604080516bffffffffffffffffffffffff19606087901b1660208201526001600160e01b031960e086901b1660348201526001600160c01b031960c085901b16603882015260009182910160405160208183030381529060405280519060200120905060006117f8826040517f19457468657265756d205369676e6564204d6573736167653a0a3332000000006020820152603c8101829052600090605c01604051602081830303815290604052805190602001209050919050565b600a549091506001600160a01b0316611811828661191d565b6001600160a01b031614925050505b949350505050565b604051630a85bd0160e11b81526000906001600160a01b0385169063150b7a029061185d903390899088908890600401612555565b6020604051808303816000875af1925050508015611898575060408051601f3d908101601f1916820190925261189591810190612592565b60015b6118f6573d8080156118c6576040519150601f19603f3d011682016040523d82523d6000602084013e6118cb565b606091505b5080516000036118ee576040516368d2bf6b60e11b815260040160405180910390fd5b805181602001fd5b6001600160e01b031916630a85bd0160e11b149050611820565b6107da8383836001611941565b600080600061192c8585611b0d565b9150915061193981611b7b565b509392505050565b6000546001600160a01b03851661196a57604051622e076360e81b815260040160405180910390fd5b8360000361198b5760405163b562e8dd60e01b815260040160405180910390fd5b6001600160a01b038516600081815260056020908152604080832080546fffffffffffffffffffffffffffffffff1981166001600160401b038083168c018116918217600160401b67ffffffffffffffff1990941690921783900481168c01811690920217909155858452600490925290912080546001600160e01b031916909217600160a01b429092169190910217905580808501838015611a3757506001600160a01b0387163b15155b15611abf575b60405182906001600160a01b038916906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a4611a886000888480600101955088611828565b611aa5576040516368d2bf6b60e11b815260040160405180910390fd5b808203611a3d578260005414611aba57600080fd5b611b04565b5b6040516001830192906001600160a01b038916906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a4808203611ac0575b506000556115a2565b6000808251604103611b435760208301516040840151606085015160001a611b3787828585611d31565b94509450505050611b74565b8251604003611b6c5760208301516040840151611b61868383611e1e565b935093505050611b74565b506000905060025b9250929050565b6000816004811115611b8f57611b8f6125af565b03611b975750565b6001816004811115611bab57611bab6125af565b03611bf85760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e6174757265000000000000000060448201526064016108a2565b6002816004811115611c0c57611c0c6125af565b03611c595760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e6774680060448201526064016108a2565b6003816004811115611c6d57611c6d6125af565b03611cc55760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604482015261756560f01b60648201526084016108a2565b6004816004811115611cd957611cd96125af565b036113235760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202776272076616c604482015261756560f01b60648201526084016108a2565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0831115611d685750600090506003611e15565b8460ff16601b14158015611d8057508460ff16601c14155b15611d915750600090506004611e15565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015611de5573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b038116611e0e57600060019250925050611e15565b9150600090505b94509492505050565b6000806001600160ff1b03831681611e3b60ff86901c601b612433565b9050611e4987828885611d31565b935093505050935093915050565b828054611e63906123ae565b90600052602060002090601f016020900481019282611e855760008555611ecb565b82601f10611e9e5782800160ff19823516178555611ecb565b82800160010185558215611ecb579182015b82811115611ecb578235825591602001919060010190611eb0565b50611ed7929150611edb565b5090565b5b80821115611ed75760008155600101611edc565b6001600160e01b03198116811461132357600080fd5b600060208284031215611f1857600080fd5b8135611f2381611ef0565b9392505050565b60005b83811015611f45578181015183820152602001611f2d565b8381111561103c5750506000910152565b60008151808452611f6e816020860160208601611f2a565b601f01601f19169290920160200192915050565b602081526000611f236020830184611f56565b600060208284031215611fa757600080fd5b5035919050565b6001600160a01b038116811461132357600080fd5b60008060408385031215611fd657600080fd5b8235611fe181611fae565b946020939093013593505050565b60008060006060848603121561200457600080fd5b833561200f81611fae565b9250602084013561201f81611fae565b929592945050506040919091013590565b6000806040838503121561204357600080fd5b82359150602083013561205581611fae565b809150509250929050565b6000806040838503121561207357600080fd5b50508035926020909101359150565b60008060006060848603121561209757600080fd5b83356120a281611fae565b95602085013595506040909401359392505050565b604080825283519082018190526000906020906060840190828701845b828110156120f0578151845292840192908401906001016120d4565b50505092019290925292915050565b60006020828403121561211157600080fd5b8135611f2381611fae565b803563ffffffff8116811461120c57600080fd5b60008083601f84011261214257600080fd5b5081356001600160401b0381111561215957600080fd5b602083019150836020828501011115611b7457600080fd5b60008060008060006080868803121561218957600080fd5b6121928661211c565b94506121a06020870161211c565b935060408601356001600160401b0380821682146121bd57600080fd5b909350606087013590808211156121d357600080fd5b506121e088828901612130565b969995985093965092949392505050565b6000806020838503121561220457600080fd5b82356001600160401b0381111561221a57600080fd5b61222685828601612130565b90969095509350505050565b6000806040838503121561224557600080fd5b823561225081611fae565b91506020830135801515811461205557600080fd5b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f191681016001600160401b03811182821017156122a3576122a3612265565b604052919050565b60006001600160401b038211156122c4576122c4612265565b50601f01601f191660200190565b600080600080608085870312156122e857600080fd5b84356122f381611fae565b9350602085013561230381611fae565b92506040850135915060608501356001600160401b0381111561232557600080fd5b8501601f8101871361233657600080fd5b8035612349612344826122ab565b61227b565b81815288602083850101111561235e57600080fd5b8160208401602083013760006020838301015280935050505092959194509250565b6000806040838503121561239357600080fd5b823561239e81611fae565b9150602083013561205581611fae565b600181811c908216806123c257607f821691505b6020821081036123e257634e487b7160e01b600052602260045260246000fd5b50919050565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b634e487b7160e01b600052601160045260246000fd5b600082198211156124465761244661241d565b500190565b60008282101561245d5761245d61241d565b500390565b634e487b7160e01b600052603260045260246000fd5b60006001820161248a5761248a61241d565b5060010190565b60008160001904831182151516156124ab576124ab61241d565b500290565b6000602082840312156124c257600080fd5b81516001600160401b038111156124d857600080fd5b8201601f810184136124e957600080fd5b80516124f7612344826122ab565b81815285602083850101111561250c57600080fd5b61251d826020830160208601611f2a565b95945050505050565b66697066733a2f2f60c81b815260008251612548816007850160208701611f2a565b9190910160070192915050565b6001600160a01b038581168252841660208201526040810183905260806060820181905260009061258890830184611f56565b9695505050505050565b6000602082840312156125a457600080fd5b8151611f2381611ef0565b634e487b7160e01b600052602160045260246000fdfea26469706673582212208fa769a1feb85ffcdeedc89c89f3b283c668dbc1ed716d9c55f69606a1821cb264736f6c634300080d0033

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

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000630000000000000000000000000000000000000000000000000000000000000015546561686f75736520486967685461626c65204f470000000000000000000000000000000000000000000000000000000000000000000000000000000000000448544f4700000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): Teahouse HighTable OG
Arg [1] : _symbol (string): HTOG
Arg [2] : _maxCollection (uint256): 99

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000063
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000015
Arg [4] : 546561686f75736520486967685461626c65204f470000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [6] : 48544f4700000000000000000000000000000000000000000000000000000000

Libraries Used

IPFSConvert : 0x74c56aedc2362629e72a777750f0c6bde0b2ec82

Deployed Bytecode Sourcemap

59473:7466:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38772:305;;;;;;;;;;-1:-1:-1;38772:305:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;38772:305:0;;;;;;;;41885:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;43388:204::-;;;;;;;;;;-1:-1:-1;43388:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1692:32:1;;;1674:51;;1662:2;1647:18;43388:204:0;1528:203:1;42951:371:0;;;;;;;;;;-1:-1:-1;42951:371:0;;;;;:::i;:::-;;:::i;:::-;;38021:303;;;;;;;;;;-1:-1:-1;66817:1:0;38275:12;38065:7;38259:13;:28;-1:-1:-1;;38259:46:0;38021:303;;;2338:25:1;;;2326:2;2311:18;38021:303:0;2192:177:1;59607:23:0;;;;;;;;;;-1:-1:-1;59607:23:0;;;;-1:-1:-1;;;;;59607:23:0;;;59713:25;;;;;;;;;;;;;:::i;44253:170::-;;;;;;;;;;-1:-1:-1;44253:170:0;;;;;:::i;:::-;;:::i;62859:191::-;;;;;;;;;;-1:-1:-1;62859:191:0;;;;;:::i;:::-;;:::i;59676:28::-;;;;;;;;;;;;;;;;63252:146;;;;;;;;;;-1:-1:-1;63252:146:0;;;;;:::i;:::-;;:::i;44494:185::-;;;;;;;;;;-1:-1:-1;44494:185:0;;;;;:::i;:::-;;:::i;64806:1522::-;;;;;;;;;;-1:-1:-1;64806:1522:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;66471:210::-;;;;;;:::i;:::-;;:::i;41693:125::-;;;;;;;;;;-1:-1:-1;41693:125:0;;;;;:::i;:::-;;:::i;39141:206::-;;;;;;;;;;-1:-1:-1;39141:206:0;;;;;:::i;:::-;;:::i;58230:103::-;;;;;;;;;;;;;:::i;57579:87::-;;;;;;;;;;-1:-1:-1;57652:6:0;;-1:-1:-1;;;;;57652:6:0;57579:87;;60297:92;;;;;;;;;;-1:-1:-1;60297:92:0;;;;;:::i;:::-;;:::i;42054:104::-;;;;;;;;;;;;;:::i;62023:655::-;;;;;;:::i;:::-;;:::i;61054:108::-;;;;;;;;;;-1:-1:-1;61054:108:0;;;;;:::i;:::-;;:::i;59637:32::-;;;;;;;;;;;;;;;;43664:287;;;;;;;;;;-1:-1:-1;43664:287:0;;;;;:::i;:::-;;:::i;64082:102::-;;;;;;;;;;-1:-1:-1;64128:14:0;38650:13;-1:-1:-1;;38650:31:0;64082:102;;44750:369;;;;;;;;;;-1:-1:-1;44750:369:0;;;;;:::i;:::-;;:::i;60812:104::-;;;;;;;;;;-1:-1:-1;60812:104:0;;;;;:::i;:::-;;:::i;63519:444::-;;;;;;;;;;-1:-1:-1;63519:444:0;;;;;:::i;:::-;;:::i;60545:132::-;;;;;;;;;;-1:-1:-1;60545:132:0;;;;;:::i;:::-;;:::i;64374:126::-;;;;;;;;;;-1:-1:-1;64374:126:0;;;;;:::i;:::-;;:::i;44022:164::-;;;;;;;;;;-1:-1:-1;44022:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;44143:25:0;;;44119:4;44143:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;44022:164;59570:30;;;;;;;;;;-1:-1:-1;59570:30:0;;;;-1:-1:-1;;;;;59570:30:0;;;58488:201;;;;;;;;;;-1:-1:-1;58488:201:0;;;;;:::i;:::-;;:::i;38772:305::-;38874:4;-1:-1:-1;;;;;;38911:40:0;;-1:-1:-1;;;38911:40:0;;:105;;-1:-1:-1;;;;;;;38968:48:0;;-1:-1:-1;;;38968:48:0;38911:105;:158;;;-1:-1:-1;;;;;;;;;;13462:40:0;;;39033:36;38891:178;38772:305;-1:-1:-1;;38772:305:0:o;41885:100::-;41939:13;41972:5;41965:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41885:100;:::o;43388:204::-;43456:7;43481:16;43489:7;43481;:16::i;:::-;43476:64;;43506:34;;-1:-1:-1;;;43506:34:0;;;;;;;;;;;43476:64;-1:-1:-1;43560:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;43560:24:0;;43388:204::o;42951:371::-;43024:13;43040:24;43056:7;43040:15;:24::i;:::-;43024:40;;43085:5;-1:-1:-1;;;;;43079:11:0;:2;-1:-1:-1;;;;;43079:11:0;;43075:48;;43099:24;;-1:-1:-1;;;43099:24:0;;;;;;;;;;;43075:48;34368:10;-1:-1:-1;;;;;43140:21:0;;;;;;:63;;-1:-1:-1;43166:37:0;43183:5;34368:10;44022:164;:::i;43166:37::-;43165:38;43140:63;43136:138;;;43227:35;;-1:-1:-1;;;43227:35:0;;;;;;;;;;;43136:138;43286:28;43295:2;43299:7;43308:5;43286:8;:28::i;:::-;43013:309;42951:371;;:::o;59713:25::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;44253:170::-;44387:28;44397:4;44403:2;44407:7;44387:9;:28::i;62859:191::-;57652:6;;-1:-1:-1;;;;;57652:6:0;34368:10;57799:23;57791:68;;;;-1:-1:-1;;;57791:68:0;;;;;;;:::i;:::-;;;;;;;;;62966:13:::1;::::0;66817:1;38275:12;38065:7;38259:13;62956:7;;38259:28;;-1:-1:-1;;38259:46:0;62940:23:::1;;;;:::i;:::-;:39;62936:70;;;62988:18;;-1:-1:-1::0;;;62988:18:0::1;;;;;;;;;;;62936:70;63019:23;63029:3;63034:7;63019:9;:23::i;:::-;62859:191:::0;;:::o;63252:146::-;66886:8;;-1:-1:-1;;;;;66886:8:0;66872:10;:22;66869:47;;66903:13;;-1:-1:-1;;;66903:13:0;;;;;;;;;;;66869:47;63344:26:::1;::::0;;;:16:::1;:26;::::0;;;;;:46;63252:146::o;44494:185::-;44632:39;44649:4;44655:2;44659:7;44632:39;;;;;;;;;;;;:16;:39::i;64806:1522::-;64899:25;64926:18;64961:6;64971:1;64961:11;64957:70;;65014:1;64998:13;;:17;;;;:::i;:::-;64989:26;;64957:70;66817:1;65043:8;:26;:53;;;;65083:13;;65073:6;:23;;65043:53;65039:89;;;65105:23;;-1:-1:-1;;;65105:23:0;;;;;;;;;;;65039:89;65141:9;65161:15;65179:16;65189:5;65179:9;:16::i;:::-;65161:34;;65210:7;65221:1;65210:12;65206:82;;65247:16;;;65261:1;65247:16;;;;;;;;65265:10;:6;65274:1;65265:10;:::i;:::-;65239:37;;;;;;;;65206:82;65314:3;65304:7;:13;65300:59;;;-1:-1:-1;65344:3:0;65300:59;65371:24;65412:7;-1:-1:-1;;;;;65398:22:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65398:22:0;;65371:49;;65431:11;65467:13;65483:17;65491:8;65483:7;:17::i;:::-;65467:33;;65520:8;65516:12;;65511:596;65535:6;65530:1;:11;65511:596;;65598:1;65567:14;;;:11;:14;;;;;:19;-1:-1:-1;;;;;65567:19:0;:33;65563:101;;-1:-1:-1;65629:14:0;;;;:11;:14;;;;;:19;-1:-1:-1;;;;;65629:19:0;65563:101;65685:14;;;;:11;:14;;;;;:21;-1:-1:-1;;;65685:21:0;;;;65684:22;:40;;;;;65719:5;-1:-1:-1;;;;;65710:14:0;:5;-1:-1:-1;;;;;65710:14:0;;65684:40;65680:416;;;65760:1;65745:7;65753:3;65745:12;;;;;;;;:::i;:::-;;;;;;;;;;:16;65780:5;;;;:::i;:::-;;;;65817:7;65810:3;:14;65806:275;;65864:16;65874:5;65864:9;:16::i;:::-;65853:7;:27;65849:213;;65917:7;65926:10;:6;65935:1;65926:10;:::i;:::-;65909:28;;;;;;;;;;;65849:213;66023:7;66032:5;:1;66036;66032:5;:::i;65849:213::-;65543:3;;;;:::i;:::-;;;;65511:596;;;66119:31;66167:3;-1:-1:-1;;;;;66153:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66153:18:0;;66119:52;;66191:1;66187:5;;66182:83;66198:3;66194:1;:7;66182:83;;;66243:7;66251:1;66243:10;;;;;;;;:::i;:::-;;;;;;;66223:14;66238:1;66223:17;;;;;;;;:::i;:::-;;;;;;;;;;:30;66203:3;;;;:::i;:::-;;;;66182:83;;;66293:14;66309:10;:6;66318:1;66309:10;:::i;:::-;66285:35;;;;;;;;;;64806:1522;;;;;;;:::o;66471:210::-;57652:6;;-1:-1:-1;;;;;57652:6:0;34368:10;57799:23;57791:68;;;;-1:-1:-1;;;57791:68:0;;;;;;;:::i;:::-;32662:1:::1;33260:7;;:19:::0;33252:63:::1;;;::::0;-1:-1:-1;;;33252:63:0;;10742:2:1;33252:63:0::1;::::0;::::1;10724:21:1::0;10781:2;10761:18;;;10754:30;10820:33;10800:18;;;10793:61;10871:18;;33252:63:0::1;10540:355:1::0;33252:63:0::1;32662:1;33393:7;:18:::0;66580:42:::2;::::0;66562:12:::2;::::0;-1:-1:-1;;;;;66580:8:0;::::2;::::0;66596:21:::2;::::0;66562:12;66580:42;66562:12;66580:42;66596:21;66580:8;:42:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66561:61;;;66638:7;66633:43;;66654:22;;-1:-1:-1::0;;;66654:22:0::2;;;;;;;;;;;66633:43;-1:-1:-1::0;;32618:1:0::1;33572:7;:22:::0;66471:210::o;41693:125::-;41757:7;41784:21;41797:7;41784:12;:21::i;:::-;:26;;41693:125;-1:-1:-1;;41693:125:0:o;39141:206::-;39205:7;-1:-1:-1;;;;;39229:19:0;;39225:60;;39257:28;;-1:-1:-1;;;39257:28:0;;;;;;;;;;;39225:60;-1:-1:-1;;;;;;39311:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;39311:27:0;;39141:206::o;58230:103::-;57652:6;;-1:-1:-1;;;;;57652:6:0;34368:10;57799:23;57791:68;;;;-1:-1:-1;;;57791:68:0;;;;;;;:::i;:::-;58295:30:::1;58322:1;58295:18;:30::i;:::-;58230:103::o:0;60297:92::-;57652:6;;-1:-1:-1;;;;;57652:6:0;34368:10;57799:23;57791:68;;;;-1:-1:-1;;;57791:68:0;;;;;;;:::i;:::-;60364:5:::1;:17:::0;60297:92::o;42054:104::-;42110:13;42143:7;42136:14;;;;;:::i;62023:655::-;62179:13;;66817:1;38275:12;38065:7;38259:13;62153:23;;;;38259:28;;-1:-1:-1;;38259:46:0;62153:23;;;;:::i;:::-;:39;62149:70;;;62201:18;;-1:-1:-1;;;62201:18:0;;;;;;;;;;;62149:70;62252:11;-1:-1:-1;;;;;62234:29:0;:15;:29;62230:62;;;62272:20;;-1:-1:-1;;;62272:20:0;;;;;;;;;;;62230:62;62321:10;39490:7;39525:19;;;:12;:19;;;;;:32;62307:50;;;;;:35;;;;;-1:-1:-1;;;39525:32:0;;-1:-1:-1;;;;;39525:32:0;62307:35;:::i;:::-;:50;62303:91;;;62366:28;;-1:-1:-1;;;62366:28:0;;;;;;;;;;;62303:91;62410:63;62423:10;62435:12;62449:11;62462:10;;62410:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62410:12:0;;-1:-1:-1;;;62410:63:0:i;:::-;62405:97;;62482:20;;-1:-1:-1;;;62482:20:0;;;;;;;;;;;62405:97;62515:18;62544:7;62536:15;;:5;;:15;;;;:::i;:::-;62515:36;;62578:10;62566:9;:22;62562:57;;;62597:22;;-1:-1:-1;;;62597:22:0;;;;;;;;;;;62562:57;62640:30;62650:10;62662:7;62640:30;;:9;:30::i;:::-;62138:540;62023:655;;;;;:::o;61054:108::-;57652:6;;-1:-1:-1;;;;;57652:6:0;34368:10;57799:23;57791:68;;;;-1:-1:-1;;;57791:68:0;;;;;;;:::i;:::-;61133:21:::1;:11;61147:7:::0;;61133:21:::1;:::i;43664:287::-:0;34368:10;-1:-1:-1;;;;;43763:24:0;;;43759:54;;43796:17;;-1:-1:-1;;;43796:17:0;;;;;;;;;;;43759:54;34368:10;43826:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;43826:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;43826:53:0;;;;;;;;;;43895:48;;540:41:1;;;43826:42:0;;34368:10;43895:48;;513:18:1;43895:48:0;;;;;;;43664:287;;:::o;44750:369::-;44917:28;44927:4;44933:2;44937:7;44917:9;:28::i;:::-;-1:-1:-1;;;;;44960:13:0;;3565:19;:23;;44960:76;;;;;44980:56;45011:4;45017:2;45021:7;45030:5;44980:30;:56::i;:::-;44979:57;44960:76;44956:156;;;45060:40;;-1:-1:-1;;;45060:40:0;;;;;;;;;;;44956:156;44750:369;;;;:::o;60812:104::-;57652:6;;-1:-1:-1;;;;;57652:6:0;34368:10;57799:23;57791:68;;;;-1:-1:-1;;;57791:68:0;;;;;;;:::i;:::-;60885:8:::1;:23:::0;;-1:-1:-1;;;;;;60885:23:0::1;-1:-1:-1::0;;;;;60885:23:0;;;::::1;::::0;;;::::1;::::0;;60812:104::o;63519:444::-;63593:17;63625;63633:8;63625:7;:17::i;:::-;63620:60;;63651:29;;-1:-1:-1;;;63651:29:0;;;;;;;;;;;63620:60;63705:26;;;;:16;:26;;;;;;:31;;63701:258;;63760:11;63753:18;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63519:444;;;:::o;63701:258::-;63813:12;63828:26;;;:16;:26;;;;;;;;63911:34;;-1:-1:-1;;;63911:34:0;;;;;2338:25:1;;;63911:11:0;;:28;;2311:18:1;;63911:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;63911:34:0;;;;;;;;;;;;:::i;:::-;63883:63;;;;;;;;:::i;:::-;;;;;;;;;;;;;63869:78;;;63519:444;;;:::o;63701:258::-;63519:444;;;:::o;60545:132::-;57652:6;;-1:-1:-1;;;;;57652:6:0;34368:10;57799:23;57791:68;;;;-1:-1:-1;;;57791:68:0;;;;;;;:::i;:::-;60632:15:::1;:37:::0;;-1:-1:-1;;;;;;60632:37:0::1;-1:-1:-1::0;;;;;60632:37:0;;;::::1;::::0;;;::::1;::::0;;60545:132::o;64374:126::-;-1:-1:-1;;;;;39525:19:0;;64436:14;39525:19;;;:12;:19;;;;;:32;-1:-1:-1;;;39525:32:0;;-1:-1:-1;;;;;39525:32:0;64470:22;39429:137;58488:201;57652:6;;-1:-1:-1;;;;;57652:6:0;34368:10;57799:23;57791:68;;;;-1:-1:-1;;;57791:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;58577:22:0;::::1;58569:73;;;::::0;-1:-1:-1;;;58569:73:0;;12744:2:1;58569:73:0::1;::::0;::::1;12726:21:1::0;12783:2;12763:18;;;12756:30;12822:34;12802:18;;;12795:62;-1:-1:-1;;;12873:18:1;;;12866:36;12919:19;;58569:73:0::1;12542:402:1::0;58569:73:0::1;58653:28;58672:8;58653:18;:28::i;:::-;58488:201:::0;:::o;45374:174::-;45431:4;45474:7;66817:1;45455:26;;:53;;;;;45495:13;;45485:7;:23;45455:53;:85;;;;-1:-1:-1;;45513:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;45513:27:0;;;;45512:28;;45374:174::o;53531:196::-;53646:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;53646:29:0;-1:-1:-1;;;;;53646:29:0;;;;;;;;;53691:28;;53646:24;;53691:28;;;;;;;53531:196;;;:::o;48474:2130::-;48589:35;48627:21;48640:7;48627:12;:21::i;:::-;48589:59;;48687:4;-1:-1:-1;;;;;48665:26:0;:13;:18;;;-1:-1:-1;;;;;48665:26:0;;48661:67;;48700:28;;-1:-1:-1;;;48700:28:0;;;;;;;;;;;48661:67;48741:22;34368:10;-1:-1:-1;;;;;48767:20:0;;;;:73;;-1:-1:-1;48804:36:0;48821:4;34368:10;44022:164;:::i;48804:36::-;48767:126;;;-1:-1:-1;34368:10:0;48857:20;48869:7;48857:11;:20::i;:::-;-1:-1:-1;;;;;48857:36:0;;48767:126;48741:153;;48912:17;48907:66;;48938:35;;-1:-1:-1;;;48938:35:0;;;;;;;;;;;48907:66;-1:-1:-1;;;;;48988:16:0;;48984:52;;49013:23;;-1:-1:-1;;;49013:23:0;;;;;;;;;;;48984:52;49157:35;49174:1;49178:7;49187:4;49157:8;:35::i;:::-;-1:-1:-1;;;;;49488:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;49488:31:0;;;-1:-1:-1;;;;;49488:31:0;;;-1:-1:-1;;49488:31:0;;;;;;;49534:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;49534:29:0;;;;;;;;;;;49614:20;;;:11;:20;;;;;;49649:18;;-1:-1:-1;;;;;;49682:49:0;;;;-1:-1:-1;;;49715:15:0;49682:49;;;;;;;;;;50005:11;;50065:24;;;;;50108:13;;49614:20;;50065:24;;50108:13;50104:384;;50318:13;;50303:11;:28;50299:174;;50356:20;;50425:28;;;;-1:-1:-1;;;;;50399:54:0;-1:-1:-1;;;50399:54:0;-1:-1:-1;;;;;;50399:54:0;;;-1:-1:-1;;;;;50356:20:0;;50399:54;;;;50299:174;49463:1036;;;50535:7;50531:2;-1:-1:-1;;;;;50516:27:0;50525:4;-1:-1:-1;;;;;50516:27:0;;;;;;;;;;;50554:42;48578:2026;;48474:2130;;;:::o;45556:104::-;45625:27;45635:2;45639:8;45625:27;;;;;;;;;;;;:9;:27::i;40522:1109::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;40633:7:0;;66817:1;40682:23;;:47;;;;;40716:13;;40709:4;:20;40682:47;40678:886;;;40750:31;40784:17;;;:11;:17;;;;;;;;;40750:51;;;;;;;;;-1:-1:-1;;;;;40750:51:0;;;;-1:-1:-1;;;40750:51:0;;-1:-1:-1;;;;;40750:51:0;;;;;;;;-1:-1:-1;;;40750:51:0;;;;;;;;;;;;;;40820:729;;40870:14;;-1:-1:-1;;;;;40870:28:0;;40866:101;;40934:9;40522:1109;-1:-1:-1;;;40522:1109:0:o;40866:101::-;-1:-1:-1;;;41309:6:0;41354:17;;;;:11;:17;;;;;;;;;41342:29;;;;;;;;;-1:-1:-1;;;;;41342:29:0;;;;;-1:-1:-1;;;41342:29:0;;-1:-1:-1;;;;;41342:29:0;;;;;;;;-1:-1:-1;;;41342:29:0;;;;;;;;;;;;;41402:28;41398:109;;41470:9;40522:1109;-1:-1:-1;;;40522:1109:0:o;41398:109::-;41269:261;;;40731:833;40678:886;41592:31;;-1:-1:-1;;;41592:31:0;;;;;;;;;;;58849:191;58942:6;;;-1:-1:-1;;;;;58959:17:0;;;-1:-1:-1;;;;;;58959:17:0;;;;;;;58992:40;;58942:6;;;58959:17;58942:6;;58992:40;;58923:16;;58992:40;58912:128;58849:191;:::o;61172:374::-;61344:52;;;-1:-1:-1;;13150:2:1;13146:15;;;13142:53;61344:52:0;;;13130:66:1;-1:-1:-1;;;;;;13252:3:1;13230:16;;;13226:43;13212:12;;;13205:65;-1:-1:-1;;;;;;13326:3:1;13304:16;;;13300:51;13286:12;;;13279:73;61299:4:0;;;;13368:12:1;61344:52:0;;;;;;;;;;;;61334:63;;;;;;61316:81;;61408:22;61433:32;:7;29737:58;;14381:66:1;29737:58:0;;;14369:79:1;14464:12;;;14457:28;;;29604:7:0;;14501:12:1;;29737:58:0;;;;;;;;;;;;29727:69;;;;;;29720:76;;29535:269;;;;61433:32;61523:15;;61408:57;;-1:-1:-1;;;;;;61523:15:0;61485:34;61408:57;61508:10;61485:22;:34::i;:::-;-1:-1:-1;;;;;61485:53:0;;61478:60;;;;61172:374;;;;;;;:::o;54219:667::-;54403:72;;-1:-1:-1;;;54403:72:0;;54382:4;;-1:-1:-1;;;;;54403:36:0;;;;;:72;;34368:10;;54454:4;;54460:7;;54469:5;;54403:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54403:72:0;;;;;;;;-1:-1:-1;;54403:72:0;;;;;;;;;;;;:::i;:::-;;;54399:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54637:6;:13;54654:1;54637:18;54633:235;;54683:40;;-1:-1:-1;;;54683:40:0;;;;;;;;;;;54633:235;54826:6;54820:13;54811:6;54807:2;54803:15;54796:38;54399:480;-1:-1:-1;;;;;;54522:55:0;-1:-1:-1;;;54522:55:0;;-1:-1:-1;54515:62:0;;46023:163;46146:32;46152:2;46156:8;46166:5;46173:4;46146:5;:32::i;25733:231::-;25811:7;25832:17;25851:18;25873:27;25884:4;25890:9;25873:10;:27::i;:::-;25831:69;;;;25911:18;25923:5;25911:11;:18::i;:::-;-1:-1:-1;25947:9:0;25733:231;-1:-1:-1;;;25733:231:0:o;46445:1775::-;46584:20;46607:13;-1:-1:-1;;;;;46635:16:0;;46631:48;;46660:19;;-1:-1:-1;;;46660:19:0;;;;;;;;;;;46631:48;46694:8;46706:1;46694:13;46690:44;;46716:18;;-1:-1:-1;;;46716:18:0;;;;;;;;;;;46690:44;-1:-1:-1;;;;;47085:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;47144:49:0;;-1:-1:-1;;;;;47085:44:0;;;;;;;47144:49;;;-1:-1:-1;;;;;47085:44:0;;;;;;47144:49;;;;;;;;;;;;;;;;47210:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;47260:66:0;;;;-1:-1:-1;;;47310:15:0;47260:66;;;;;;;;;;47210:25;47407:23;;;47451:4;:23;;;;-1:-1:-1;;;;;;47459:13:0;;3565:19;:23;;47459:15;47447:641;;;47495:314;47526:38;;47551:12;;-1:-1:-1;;;;;47526:38:0;;;47543:1;;47526:38;;47543:1;;47526:38;47592:69;47631:1;47635:2;47639:14;;;;;;47655:5;47592:30;:69::i;:::-;47587:174;;47697:40;;-1:-1:-1;;;47697:40:0;;;;;;;;;;;47587:174;47804:3;47788:12;:19;47495:314;;47890:12;47873:13;;:29;47869:43;;47904:8;;;47869:43;47447:641;;;47953:120;47984:40;;48009:14;;;;;-1:-1:-1;;;;;47984:40:0;;;48001:1;;47984:40;;48001:1;;47984:40;48068:3;48052:12;:19;47953:120;;47447:641;-1:-1:-1;48102:13:0;:28;48152:60;44750:369;23623:1308;23704:7;23713:12;23938:9;:16;23958:2;23938:22;23934:990;;24234:4;24219:20;;24213:27;24284:4;24269:20;;24263:27;24342:4;24327:20;;24321:27;23977:9;24313:36;24385:25;24396:4;24313:36;24213:27;24263;24385:10;:25::i;:::-;24378:32;;;;;;;;;23934:990;24432:9;:16;24452:2;24432:22;24428:496;;24707:4;24692:20;;24686:27;24758:4;24743:20;;24737:27;24800:23;24811:4;24686:27;24737;24800:10;:23::i;:::-;24793:30;;;;;;;;24428:496;-1:-1:-1;24872:1:0;;-1:-1:-1;24876:35:0;24428:496;23623:1308;;;;;:::o;21894:643::-;21972:20;21963:5;:29;;;;;;;;:::i;:::-;;21959:571;;21894:643;:::o;21959:571::-;22070:29;22061:5;:38;;;;;;;;:::i;:::-;;22057:473;;22116:34;;-1:-1:-1;;;22116:34:0;;14858:2:1;22116:34:0;;;14840:21:1;14897:2;14877:18;;;14870:30;14936:26;14916:18;;;14909:54;14980:18;;22116:34:0;14656:348:1;22057:473:0;22181:35;22172:5;:44;;;;;;;;:::i;:::-;;22168:362;;22233:41;;-1:-1:-1;;;22233:41:0;;15211:2:1;22233:41:0;;;15193:21:1;15250:2;15230:18;;;15223:30;15289:33;15269:18;;;15262:61;15340:18;;22233:41:0;15009:355:1;22168:362:0;22305:30;22296:5;:39;;;;;;;;:::i;:::-;;22292:238;;22352:44;;-1:-1:-1;;;22352:44:0;;15571:2:1;22352:44:0;;;15553:21:1;15610:2;15590:18;;;15583:30;15649:34;15629:18;;;15622:62;-1:-1:-1;;;15700:18:1;;;15693:32;15742:19;;22352:44:0;15369:398:1;22292:238:0;22427:30;22418:5;:39;;;;;;;;:::i;:::-;;22414:116;;22474:44;;-1:-1:-1;;;22474:44:0;;15974:2:1;22474:44:0;;;15956:21:1;16013:2;15993:18;;;15986:30;16052:34;16032:18;;;16025:62;-1:-1:-1;;;16103:18:1;;;16096:32;16145:19;;22474:44:0;15772:398:1;27185:1632:0;27316:7;;28250:66;28237:79;;28233:163;;;-1:-1:-1;28349:1:0;;-1:-1:-1;28353:30:0;28333:51;;28233:163;28410:1;:7;;28415:2;28410:7;;:18;;;;;28421:1;:7;;28426:2;28421:7;;28410:18;28406:102;;;-1:-1:-1;28461:1:0;;-1:-1:-1;28465:30:0;28445:51;;28406:102;28622:24;;;28605:14;28622:24;;;;;;;;;16402:25:1;;;16475:4;16463:17;;16443:18;;;16436:45;;;;16497:18;;;16490:34;;;16540:18;;;16533:34;;;28622:24:0;;16374:19:1;;28622:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;28622:24:0;;-1:-1:-1;;28622:24:0;;;-1:-1:-1;;;;;;;28661:20:0;;28657:103;;28714:1;28718:29;28698:50;;;;;;;28657:103;28780:6;-1:-1:-1;28788:20:0;;-1:-1:-1;27185:1632:0;;;;;;;;:::o;26227:344::-;26341:7;;-1:-1:-1;;;;;26387:80:0;;26341:7;26494:25;26510:3;26495:18;;;26517:2;26494:25;:::i;:::-;26478:42;;26538:25;26549:4;26555:1;26558;26561;26538:10;:25::i;:::-;26531:32;;;;;;26227:344;;;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;:::-;384:5;150:245;-1:-1:-1;;;150:245:1:o;592:258::-;664:1;674:113;688:6;685:1;682:13;674:113;;;764:11;;;758:18;745:11;;;738:39;710:2;703:10;674:113;;;805:6;802:1;799:13;796:48;;;-1:-1:-1;;840:1:1;822:16;;815:27;592:258::o;855:::-;897:3;935:5;929:12;962:6;957:3;950:19;978:63;1034:6;1027:4;1022:3;1018:14;1011:4;1004:5;1000:16;978:63;:::i;:::-;1095:2;1074:15;-1:-1:-1;;1070:29:1;1061:39;;;;1102:4;1057:50;;855:258;-1:-1:-1;;855:258:1:o;1118:220::-;1267:2;1256:9;1249:21;1230:4;1287:45;1328:2;1317:9;1313:18;1305:6;1287:45;:::i;1343:180::-;1402:6;1455:2;1443:9;1434:7;1430:23;1426:32;1423:52;;;1471:1;1468;1461:12;1423:52;-1:-1:-1;1494:23:1;;1343:180;-1:-1:-1;1343:180:1:o;1736:131::-;-1:-1:-1;;;;;1811:31:1;;1801:42;;1791:70;;1857:1;1854;1847:12;1872:315;1940:6;1948;2001:2;1989:9;1980:7;1976:23;1972:32;1969:52;;;2017:1;2014;2007:12;1969:52;2056:9;2043:23;2075:31;2100:5;2075:31;:::i;:::-;2125:5;2177:2;2162:18;;;;2149:32;;-1:-1:-1;;;1872:315:1:o;2374:456::-;2451:6;2459;2467;2520:2;2508:9;2499:7;2495:23;2491:32;2488:52;;;2536:1;2533;2526:12;2488:52;2575:9;2562:23;2594:31;2619:5;2594:31;:::i;:::-;2644:5;-1:-1:-1;2701:2:1;2686:18;;2673:32;2714:33;2673:32;2714:33;:::i;:::-;2374:456;;2766:7;;-1:-1:-1;;;2820:2:1;2805:18;;;;2792:32;;2374:456::o;2835:315::-;2903:6;2911;2964:2;2952:9;2943:7;2939:23;2935:32;2932:52;;;2980:1;2977;2970:12;2932:52;3016:9;3003:23;2993:33;;3076:2;3065:9;3061:18;3048:32;3089:31;3114:5;3089:31;:::i;:::-;3139:5;3129:15;;;2835:315;;;;;:::o;3155:248::-;3223:6;3231;3284:2;3272:9;3263:7;3259:23;3255:32;3252:52;;;3300:1;3297;3290:12;3252:52;-1:-1:-1;;3323:23:1;;;3393:2;3378:18;;;3365:32;;-1:-1:-1;3155:248:1:o;3408:383::-;3485:6;3493;3501;3554:2;3542:9;3533:7;3529:23;3525:32;3522:52;;;3570:1;3567;3560:12;3522:52;3609:9;3596:23;3628:31;3653:5;3628:31;:::i;:::-;3678:5;3730:2;3715:18;;3702:32;;-1:-1:-1;3781:2:1;3766:18;;;3753:32;;3408:383;-1:-1:-1;;;3408:383:1:o;3796:705::-;4014:2;4026:21;;;4096:13;;3999:18;;;4118:22;;;3966:4;;4193;;4171:2;4156:18;;;4220:15;;;3966:4;4263:169;4277:6;4274:1;4271:13;4263:169;;;4338:13;;4326:26;;4372:12;;;;4407:15;;;;4299:1;4292:9;4263:169;;;-1:-1:-1;;;4468:18:1;;4461:34;;;;4449:3;3796:705;-1:-1:-1;;3796:705:1:o;4506:255::-;4573:6;4626:2;4614:9;4605:7;4601:23;4597:32;4594:52;;;4642:1;4639;4632:12;4594:52;4681:9;4668:23;4700:31;4725:5;4700:31;:::i;5018:163::-;5085:20;;5145:10;5134:22;;5124:33;;5114:61;;5171:1;5168;5161:12;5186:347;5237:8;5247:6;5301:3;5294:4;5286:6;5282:17;5278:27;5268:55;;5319:1;5316;5309:12;5268:55;-1:-1:-1;5342:20:1;;-1:-1:-1;;;;;5374:30:1;;5371:50;;;5417:1;5414;5407:12;5371:50;5454:4;5446:6;5442:17;5430:29;;5506:3;5499:4;5490:6;5482;5478:19;5474:30;5471:39;5468:59;;;5523:1;5520;5513:12;5538:731;5632:6;5640;5648;5656;5664;5717:3;5705:9;5696:7;5692:23;5688:33;5685:53;;;5734:1;5731;5724:12;5685:53;5757:28;5775:9;5757:28;:::i;:::-;5747:38;;5804:37;5837:2;5826:9;5822:18;5804:37;:::i;:::-;5794:47;;5891:2;5880:9;5876:18;5863:32;-1:-1:-1;;;;;5972:2:1;5965:5;5961:14;5954:5;5951:25;5941:53;;5990:1;5987;5980:12;5941:53;6013:5;;-1:-1:-1;6069:2:1;6054:18;;6041:32;;6085:14;;;6082:34;;;6112:1;6109;6102:12;6082:34;;6151:58;6201:7;6192:6;6181:9;6177:22;6151:58;:::i;:::-;5538:731;;;;-1:-1:-1;5538:731:1;;-1:-1:-1;6228:8:1;;6125:84;5538:731;-1:-1:-1;;;5538:731:1:o;6274:410::-;6345:6;6353;6406:2;6394:9;6385:7;6381:23;6377:32;6374:52;;;6422:1;6419;6412:12;6374:52;6462:9;6449:23;-1:-1:-1;;;;;6487:6:1;6484:30;6481:50;;;6527:1;6524;6517:12;6481:50;6566:58;6616:7;6607:6;6596:9;6592:22;6566:58;:::i;:::-;6643:8;;6540:84;;-1:-1:-1;6274:410:1;-1:-1:-1;;;;6274:410:1:o;6689:416::-;6754:6;6762;6815:2;6803:9;6794:7;6790:23;6786:32;6783:52;;;6831:1;6828;6821:12;6783:52;6870:9;6857:23;6889:31;6914:5;6889:31;:::i;:::-;6939:5;-1:-1:-1;6996:2:1;6981:18;;6968:32;7038:15;;7031:23;7019:36;;7009:64;;7069:1;7066;7059:12;7110:127;7171:10;7166:3;7162:20;7159:1;7152:31;7202:4;7199:1;7192:15;7226:4;7223:1;7216:15;7242:275;7313:2;7307:9;7378:2;7359:13;;-1:-1:-1;;7355:27:1;7343:40;;-1:-1:-1;;;;;7398:34:1;;7434:22;;;7395:62;7392:88;;;7460:18;;:::i;:::-;7496:2;7489:22;7242:275;;-1:-1:-1;7242:275:1:o;7522:186::-;7570:4;-1:-1:-1;;;;;7595:6:1;7592:30;7589:56;;;7625:18;;:::i;:::-;-1:-1:-1;7691:2:1;7670:15;-1:-1:-1;;7666:29:1;7697:4;7662:40;;7522:186::o;7713:1016::-;7808:6;7816;7824;7832;7885:3;7873:9;7864:7;7860:23;7856:33;7853:53;;;7902:1;7899;7892:12;7853:53;7941:9;7928:23;7960:31;7985:5;7960:31;:::i;:::-;8010:5;-1:-1:-1;8067:2:1;8052:18;;8039:32;8080:33;8039:32;8080:33;:::i;:::-;8132:7;-1:-1:-1;8186:2:1;8171:18;;8158:32;;-1:-1:-1;8241:2:1;8226:18;;8213:32;-1:-1:-1;;;;;8257:30:1;;8254:50;;;8300:1;8297;8290:12;8254:50;8323:22;;8376:4;8368:13;;8364:27;-1:-1:-1;8354:55:1;;8405:1;8402;8395:12;8354:55;8441:2;8428:16;8466:48;8482:31;8510:2;8482:31;:::i;:::-;8466:48;:::i;:::-;8537:2;8530:5;8523:17;8577:7;8572:2;8567;8563;8559:11;8555:20;8552:33;8549:53;;;8598:1;8595;8588:12;8549:53;8653:2;8648;8644;8640:11;8635:2;8628:5;8624:14;8611:45;8697:1;8692:2;8687;8680:5;8676:14;8672:23;8665:34;8718:5;8708:15;;;;;7713:1016;;;;;;;:::o;8734:388::-;8802:6;8810;8863:2;8851:9;8842:7;8838:23;8834:32;8831:52;;;8879:1;8876;8869:12;8831:52;8918:9;8905:23;8937:31;8962:5;8937:31;:::i;:::-;8987:5;-1:-1:-1;9044:2:1;9029:18;;9016:32;9057:33;9016:32;9057:33;:::i;9127:380::-;9206:1;9202:12;;;;9249;;;9270:61;;9324:4;9316:6;9312:17;9302:27;;9270:61;9377:2;9369:6;9366:14;9346:18;9343:38;9340:161;;9423:10;9418:3;9414:20;9411:1;9404:31;9458:4;9455:1;9448:15;9486:4;9483:1;9476:15;9340:161;;9127:380;;;:::o;9512:356::-;9714:2;9696:21;;;9733:18;;;9726:30;9792:34;9787:2;9772:18;;9765:62;9859:2;9844:18;;9512:356::o;9873:127::-;9934:10;9929:3;9925:20;9922:1;9915:31;9965:4;9962:1;9955:15;9989:4;9986:1;9979:15;10005:128;10045:3;10076:1;10072:6;10069:1;10066:13;10063:39;;;10082:18;;:::i;:::-;-1:-1:-1;10118:9:1;;10005:128::o;10138:125::-;10178:4;10206:1;10203;10200:8;10197:34;;;10211:18;;:::i;:::-;-1:-1:-1;10248:9:1;;10138:125::o;10268:127::-;10329:10;10324:3;10320:20;10317:1;10310:31;10360:4;10357:1;10350:15;10384:4;10381:1;10374:15;10400:135;10439:3;10460:17;;;10457:43;;10480:18;;:::i;:::-;-1:-1:-1;10527:1:1;10516:13;;10400:135::o;11110:168::-;11150:7;11216:1;11212;11208:6;11204:14;11201:1;11198:21;11193:1;11186:9;11179:17;11175:45;11172:71;;;11223:18;;:::i;:::-;-1:-1:-1;11263:9:1;;11110:168::o;11473:635::-;11553:6;11606:2;11594:9;11585:7;11581:23;11577:32;11574:52;;;11622:1;11619;11612:12;11574:52;11655:9;11649:16;-1:-1:-1;;;;;11680:6:1;11677:30;11674:50;;;11720:1;11717;11710:12;11674:50;11743:22;;11796:4;11788:13;;11784:27;-1:-1:-1;11774:55:1;;11825:1;11822;11815:12;11774:55;11854:2;11848:9;11879:48;11895:31;11923:2;11895:31;:::i;11879:48::-;11950:2;11943:5;11936:17;11990:7;11985:2;11980;11976;11972:11;11968:20;11965:33;11962:53;;;12011:1;12008;12001:12;11962:53;12024:54;12075:2;12070;12063:5;12059:14;12054:2;12050;12046:11;12024:54;:::i;:::-;12097:5;11473:635;-1:-1:-1;;;;;11473:635:1:o;12113:424::-;-1:-1:-1;;;12370:3:1;12363:22;12345:3;12414:6;12408:13;12430:61;12484:6;12480:1;12475:3;12471:11;12464:4;12456:6;12452:17;12430:61;:::i;:::-;12511:16;;;;12529:1;12507:24;;12113:424;-1:-1:-1;;12113:424:1:o;13391:489::-;-1:-1:-1;;;;;13660:15:1;;;13642:34;;13712:15;;13707:2;13692:18;;13685:43;13759:2;13744:18;;13737:34;;;13807:3;13802:2;13787:18;;13780:31;;;13585:4;;13828:46;;13854:19;;13846:6;13828:46;:::i;:::-;13820:54;13391:489;-1:-1:-1;;;;;;13391:489:1:o;13885:249::-;13954:6;14007:2;13995:9;13986:7;13982:23;13978:32;13975:52;;;14023:1;14020;14013:12;13975:52;14055:9;14049:16;14074:30;14098:5;14074:30;:::i;14524:127::-;14585:10;14580:3;14576:20;14573:1;14566:31;14616:4;14613:1;14606:15;14640:4;14637:1;14630:15

Swarm Source

ipfs://8fa769a1feb85ffcdeedc89c89f3b283c668dbc1ed716d9c55f69606a1821cb2

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