Token

Exponentials (EXP)

ERC-721

NFT

Overview

Max Total Supply

820 EXP

Holders

466

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x4c102bb3eaa54a52c85d529786d0d4389f48dd99

Filtered by Token Holder

0x54B065B3a70157F5e120CDB9F0CA8fCA8F664e53

knoxis.eth

Balance

2 EXP

0x54B065B3a70157F5e120CDB9F0CA8fCA8F664e53

OVERVIEW

Exponentials is a living art experiment composed of 1000 NFTs on the blockchain designed to shed light on our collective cognitive biases towards exponential growth.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

ExpNFT

Compiler Version

v0.8.9+commit.e5eed63a

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-11-26
*/

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.3.2 (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);
}

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



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

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





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

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



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

// OpenZeppelin Contracts v4.3.2 (access/IAccessControl.sol)



/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}

// OpenZeppelin Contracts v4.3.2 (token/ERC721/IERC721.sol)





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





// OpenZeppelin Contracts v4.3.2 (token/ERC721/extensions/ERC721Enumerable.sol)




// OpenZeppelin Contracts v4.3.2 (token/ERC721/ERC721.sol)





// OpenZeppelin Contracts v4.3.2 (token/ERC721/IERC721Receiver.sol)



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


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





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


// OpenZeppelin Contracts v4.3.2 (utils/Address.sol)



/**
 * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 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);
            }
        }
    }
}





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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);
    }

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

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

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

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


// OpenZeppelin Contracts v4.3.2 (token/ERC721/extensions/IERC721Enumerable.sol)





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

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

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


/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

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

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}


// OpenZeppelin Contracts v4.3.2 (access/AccessControlEnumerable.sol)




// OpenZeppelin Contracts v4.3.2 (access/IAccessControlEnumerable.sol)





/**
 * @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
 */
interface IAccessControlEnumerable is IAccessControl {
    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) external view returns (address);

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) external view returns (uint256);
}


// OpenZeppelin Contracts v4.3.2 (access/AccessControl.sol)








/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role, _msgSender());
        _;
    }

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

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(uint160(account), 20),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}


// OpenZeppelin Contracts v4.3.2 (utils/structs/EnumerableSet.sol)



/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastvalue;
                // Update the index for the moved value
                set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}


/**
 * @dev Extension of {AccessControl} that allows enumerating the members of each role.
 */
abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl {
    using EnumerableSet for EnumerableSet.AddressSet;

    mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers;

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

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) public view override returns (address) {
        return _roleMembers[role].at(index);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view override returns (uint256) {
        return _roleMembers[role].length();
    }

    /**
     * @dev Overload {grantRole} to track enumerable memberships
     */
    function grantRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {
        super.grantRole(role, account);
        _roleMembers[role].add(account);
    }

    /**
     * @dev Overload {revokeRole} to track enumerable memberships
     */
    function revokeRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {
        super.revokeRole(role, account);
        _roleMembers[role].remove(account);
    }

    /**
     * @dev Overload {renounceRole} to track enumerable memberships
     */
    function renounceRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {
        super.renounceRole(role, account);
        _roleMembers[role].remove(account);
    }

    /**
     * @dev Overload {_setupRole} to track enumerable memberships
     */
    function _setupRole(bytes32 role, address account) internal virtual override {
        super._setupRole(role, account);
        _roleMembers[role].add(account);
    }
}


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





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


// OpenZeppelin Contracts v4.3.2 (utils/Counters.sol)



/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}



contract ExpNFT is Context, AccessControlEnumerable, ERC721, ERC721Enumerable, Ownable {
  using Counters for Counters.Counter;

  string base_uri_head = "https://exponentials.art/metadata/";
  string base_uri_tail = ".json";

  Counters.Counter private _tokenIdTracker;

  uint public pricePerNFT = 0.02 ether;

  uint constant public maxNFTPerCall = 20;
  uint constant public teamSupply = 50;

  uint constant public maxTotalSupply = 1000;
  uint constant public publicSupply = maxTotalSupply - teamSupply;

  bool saleStarted = false;

  bool public teamTokensMinted = false;
  uint public tokensBurned = 0;

  mapping(address => bool) public giveAwayWhiteList;

  constructor() ERC721("Exponentials", "EXP") {
        _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
  }

  function setPrice(uint newPrice) public {
    require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "Caller cannot alter state");
    pricePerNFT = newPrice;
  }

  function toggleSaleState() public {
    require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "Caller cannot alter state");
    saleStarted = !saleStarted;
  }

  function addToGiveAwayWhiteList(address[] memory users) public {
    require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "Caller cannot alter whiteList");
    for(uint i=0; i<users.length; i++) {
      giveAwayWhiteList[users[i]] = true;
    }
  }

  function removeFromGiveAwayWhiteList(address[] memory users) public {
    require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "Caller cannot alter whiteList");
    for(uint i=0; i<users.length; i++) {
      giveAwayWhiteList[users[i]] = false;
    }
  }

  function withdraw() public {
    require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "Caller cannot withdraw");
    payable(owner()).call{value: address(this).balance}("");
  }

  function makeTeamMints() public {
    require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "Caller cannot mint team tokens");
    require(!teamTokensMinted, "Team tokens have already been minted");
    for (uint i=0; i<teamSupply; i++) {
      _mint(owner(), _tokenIdTracker.current());
      _tokenIdTracker.increment();
    }
    teamTokensMinted = true;
  }

  function mint(uint _amount) public payable {
    require(_amount > 0, "Minting 0 tokens is quite useless");
    require(_amount <= maxNFTPerCall, "Amount is higher than maximum per call");
    require(saleIsActive(), "Sale is not active");

    if (giveAwayWhiteList[_msgSender()]) {
      _amount--;
      giveAwayWhiteList[_msgSender()] = false;
      _mint(_msgSender(), _tokenIdTracker.current());
      _tokenIdTracker.increment();
    }

    uint bound; 
    if (teamTokensMinted) {
      bound = maxTotalSupply;
    }
    else { 
      bound = publicSupply;
    }

    if (_amount+_tokenIdTracker.current() > bound) {
      _amount = bound-_tokenIdTracker.current();
    }

    uint amountToPay = _amount*pricePerNFT;
    require(amountToPay <= msg.value, "Provided not enough Ether for purchase");
    for (uint i=0; i<_amount; i++) {
      _mint(_msgSender(), _tokenIdTracker.current());
      _tokenIdTracker.increment();
    }
    if (msg.value > amountToPay) {
      payable(_msgSender()).call{value: msg.value - amountToPay}("");
    }
  }

  function burnMany(uint256[] calldata tokenIds) public {
    require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "Caller cannot alter state");
    for (uint i; i<tokenIds.length; i++) {
      _burn(tokenIds[i]);
    }
    tokensBurned += tokenIds.length;
  }

  function tokensMinted() public view returns(uint) {
    return _tokenIdTracker.current();
  }

  function saleIsActive() public view returns(bool){
    if (teamTokensMinted) {
      return (saleStarted && _tokenIdTracker.current() < maxTotalSupply);
    }
    else {
      return (saleStarted && _tokenIdTracker.current() < publicSupply);
    }
  }

  function tokenURI(uint256 _tokenId) public view override returns (string memory) {
    return string(abi.encodePacked(base_uri_head, Strings.toString(_tokenId), base_uri_tail));
  }

  /** * @dev See {IERC165-supportsInterface}.  */
  function supportsInterface(bytes4 interfaceId) public view virtual
  override(ERC721, ERC721Enumerable, AccessControlEnumerable) returns (bool)
  {
    return super.supportsInterface(interfaceId);
  }

  function _beforeTokenTransfer( address from, address to, uint256 tokenId) internal virtual override(ERC721, ERC721Enumerable) {
    super._beforeTokenTransfer(from, to, tokenId);
  }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"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":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"users","type":"address[]"}],"name":"addToGiveAwayWhiteList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"burnMany","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":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"giveAwayWhiteList","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"makeTeamMints","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxNFTPerCall","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pricePerNFT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"users","type":"address[]"}],"name":"removeFromGiveAwayWhiteList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamTokensMinted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toggleSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokensBurned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokensMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

60e060405260226080818152906200333260a03980516200002991600d91602090910190620002d2565b5060408051808201909152600580825264173539b7b760d91b60209092019182526200005891600e91620002d2565b5066470de4df8200006010556011805461ffff1916905560006012553480156200008157600080fd5b50604080518082018252600c81526b4578706f6e656e7469616c7360a01b60208083019182528351808501909452600384526204558560ec1b908401528151919291620000d191600291620002d2565b508051620000e7906003906020840190620002d2565b50505062000104620000fe6200011760201b60201c565b6200011b565b620001116000336200016d565b620003b5565b3390565b600c80546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b620001848282620001b060201b6200167a1760201c565b6000828152600160209081526040909120620001ab91839062001684620001c0821b17901c565b505050565b620001bc8282620001e0565b5050565b6000620001d7836001600160a01b03841662000280565b90505b92915050565b6000828152602081815260408083206001600160a01b038516845290915290205460ff16620001bc576000828152602081815260408083206001600160a01b03851684529091529020805460ff191660011790556200023c3390565b6001600160a01b0316816001600160a01b0316837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45050565b6000818152600183016020526040812054620002c957508154600181810184556000848152602080822090930184905584548482528286019093526040902091909155620001da565b506000620001da565b828054620002e09062000378565b90600052602060002090601f0160209004810192826200030457600085556200034f565b82601f106200031f57805160ff19168380011785556200034f565b828001600101855582156200034f579182015b828111156200034f57825182559160200191906001019062000332565b506200035d92915062000361565b5090565b5b808211156200035d576000815560010162000362565b600181811c908216806200038d57607f821691505b60208210811415620003af57634e487b7160e01b600052602260045260246000fd5b50919050565b612f6d80620003c56000396000f3fe6080604052600436106102725760003560e01c806383b60d771161014f578063a8edeeb6116100c1578063d547741f1161007a578063d547741f14610724578063daaeec8614610744578063e7873b5814610759578063e985e9c51461076f578063eb8d2444146107b8578063f2fde38b146107cd57600080fd5b8063a8edeeb614610654578063b88d4fde14610684578063c87b56dd146106a4578063ca15c873146106c4578063cf323460146106e4578063d09893901461070457600080fd5b806391d148541161011357806391d14854146105c257806395d89b41146105e2578063a0712d68146105f7578063a217fddf1461060a578063a22cb4651461061f578063a6bf16471461063f57600080fd5b806383b60d771461052f5780638b5f9f65146105445780638da5cb5b146105645780639010d07c1461058257806391b7f5ed146105a257600080fd5b80632f2ff15d116101e85780634f6ccce7116101ac5780634f6ccce7146104905780635e84d723146104b05780636352211e146104c55780636de9f32b146104e557806370a08231146104fa578063715018a61461051a57600080fd5b80632f2ff15d146103fb5780632f745c591461041b57806336568abe1461043b5780633ccfd60b1461045b57806342842e0e1461047057600080fd5b806318160ddd1161023a57806318160ddd1461034c57806322cb1ec81461036157806323b872dd14610380578063248a9ca3146103a05780632ab4d052146103d05780632cfac6ec146103e657600080fd5b806301ffc9a7146102775780630628aa70146102ac57806306fdde03146102d0578063081812fc146102f2578063095ea7b31461032a575b600080fd5b34801561028357600080fd5b5061029761029236600461276b565b6107ed565b60405190151581526020015b60405180910390f35b3480156102b857600080fd5b506102c260105481565b6040519081526020016102a3565b3480156102dc57600080fd5b506102e56107fe565b6040516102a391906127e0565b3480156102fe57600080fd5b5061031261030d3660046127f3565b610890565b6040516001600160a01b0390911681526020016102a3565b34801561033657600080fd5b5061034a610345366004612828565b61092a565b005b34801561035857600080fd5b50600a546102c2565b34801561036d57600080fd5b5060115461029790610100900460ff1681565b34801561038c57600080fd5b5061034a61039b366004612852565b610a40565b3480156103ac57600080fd5b506102c26103bb3660046127f3565b60009081526020819052604090206001015490565b3480156103dc57600080fd5b506102c26103e881565b3480156103f257600080fd5b506102c2603281565b34801561040757600080fd5b5061034a61041636600461288e565b610a71565b34801561042757600080fd5b506102c2610436366004612828565b610a93565b34801561044757600080fd5b5061034a61045636600461288e565b610b29565b34801561046757600080fd5b5061034a610b4b565b34801561047c57600080fd5b5061034a61048b366004612852565b610be8565b34801561049c57600080fd5b506102c26104ab3660046127f3565b610c03565b3480156104bc57600080fd5b506102c2610c96565b3480156104d157600080fd5b506103126104e03660046127f3565b610ca6565b3480156104f157600080fd5b506102c2610d1d565b34801561050657600080fd5b506102c26105153660046128ba565b610d2d565b34801561052657600080fd5b5061034a610db4565b34801561053b57600080fd5b5061034a610e1a565b34801561055057600080fd5b5061034a61055f36600461291c565b610f30565b34801561057057600080fd5b50600c546001600160a01b0316610312565b34801561058e57600080fd5b5061031261059d3660046129c9565b610ff3565b3480156105ae57600080fd5b5061034a6105bd3660046127f3565b611012565b3480156105ce57600080fd5b506102976105dd36600461288e565b61103e565b3480156105ee57600080fd5b506102e5611067565b61034a6106053660046127f3565b611076565b34801561061657600080fd5b506102c2600081565b34801561062b57600080fd5b5061034a61063a3660046129eb565b611342565b34801561064b57600080fd5b506102c2601481565b34801561066057600080fd5b5061029761066f3660046128ba565b60136020526000908152604090205460ff1681565b34801561069057600080fd5b5061034a61069f366004612a27565b61134d565b3480156106b057600080fd5b506102e56106bf3660046127f3565b611385565b3480156106d057600080fd5b506102c26106df3660046127f3565b6113bc565b3480156106f057600080fd5b5061034a6106ff366004612ae7565b6113d3565b34801561071057600080fd5b5061034a61071f36600461291c565b611457565b34801561073057600080fd5b5061034a61073f36600461288e565b611516565b34801561075057600080fd5b5061034a611520565b34801561076557600080fd5b506102c260125481565b34801561077b57600080fd5b5061029761078a366004612b5c565b6001600160a01b03918216600090815260076020908152604080832093909416825291909152205460ff1690565b3480156107c457600080fd5b5061029761155b565b3480156107d957600080fd5b5061034a6107e83660046128ba565b6115af565b60006107f882611699565b92915050565b60606002805461080d90612b86565b80601f016020809104026020016040519081016040528092919081815260200182805461083990612b86565b80156108865780601f1061085b57610100808354040283529160200191610886565b820191906000526020600020905b81548152906001019060200180831161086957829003601f168201915b5050505050905090565b6000818152600460205260408120546001600160a01b031661090e5760405162461bcd60e51b815260206004820152602c60248201527f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860448201526b34b9ba32b73a103a37b5b2b760a11b60648201526084015b60405180910390fd5b506000908152600660205260409020546001600160a01b031690565b600061093582610ca6565b9050806001600160a01b0316836001600160a01b031614156109a35760405162461bcd60e51b815260206004820152602160248201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e656044820152603960f91b6064820152608401610905565b336001600160a01b03821614806109bf57506109bf813361078a565b610a315760405162461bcd60e51b815260206004820152603860248201527f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760448201527f6e6572206e6f7220617070726f76656420666f7220616c6c00000000000000006064820152608401610905565b610a3b83836116be565b505050565b610a4a338261172c565b610a665760405162461bcd60e51b815260040161090590612bc1565b610a3b838383611823565b610a7b82826119ce565b6000828152600160205260409020610a3b9082611684565b6000610a9e83610d2d565b8210610b005760405162461bcd60e51b815260206004820152602b60248201527f455243373231456e756d657261626c653a206f776e657220696e646578206f7560448201526a74206f6620626f756e647360a81b6064820152608401610905565b506001600160a01b03919091166000908152600860209081526040808320938352929052205490565b610b3382826119f4565b6000828152600160205260409020610a3b9082611a6e565b610b5660003361103e565b610b9b5760405162461bcd60e51b815260206004820152601660248201527543616c6c65722063616e6e6f7420776974686472617760501b6044820152606401610905565b600c546040516001600160a01b03909116904790600081818185875af1925050503d8060008114610a3b576040519150601f19603f3d011682016040523d82523d6000602084013e505050565b610a3b8383836040518060200160405280600081525061134d565b6000610c0e600a5490565b8210610c715760405162461bcd60e51b815260206004820152602c60248201527f455243373231456e756d657261626c653a20676c6f62616c20696e646578206f60448201526b7574206f6620626f756e647360a01b6064820152608401610905565b600a8281548110610c8457610c84612c12565b90600052602060002001549050919050565b610ca360326103e8612c3e565b81565b6000818152600460205260408120546001600160a01b0316806107f85760405162461bcd60e51b815260206004820152602960248201527f4552433732313a206f776e657220717565727920666f72206e6f6e657869737460448201526832b73a103a37b5b2b760b91b6064820152608401610905565b6000610d28600f5490565b905090565b60006001600160a01b038216610d985760405162461bcd60e51b815260206004820152602a60248201527f4552433732313a2062616c616e636520717565727920666f7220746865207a65604482015269726f206164647265737360b01b6064820152608401610905565b506001600160a01b031660009081526005602052604090205490565b600c546001600160a01b03163314610e0e5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610905565b610e186000611a83565b565b610e2560003361103e565b610e715760405162461bcd60e51b815260206004820152601e60248201527f43616c6c65722063616e6e6f74206d696e74207465616d20746f6b656e7300006044820152606401610905565b601154610100900460ff1615610ed55760405162461bcd60e51b8152602060048201526024808201527f5465616d20746f6b656e73206861766520616c7265616479206265656e206d696044820152631b9d195960e21b6064820152608401610905565b60005b6032811015610f1e57610efe610ef6600c546001600160a01b031690565b600f54611ad5565b610f0c600f80546001019055565b80610f1681612c55565b915050610ed8565b506011805461ff001916610100179055565b610f3b60003361103e565b610f875760405162461bcd60e51b815260206004820152601d60248201527f43616c6c65722063616e6e6f7420616c7465722077686974654c6973740000006044820152606401610905565b60005b8151811015610fef57600060136000848481518110610fab57610fab612c12565b6020908102919091018101516001600160a01b03168252810191909152604001600020805460ff191691151591909117905580610fe781612c55565b915050610f8a565b5050565b600082815260016020526040812061100b9083611c23565b9392505050565b61101d60003361103e565b6110395760405162461bcd60e51b815260040161090590612c70565b601055565b6000918252602082815260408084206001600160a01b0393909316845291905290205460ff1690565b60606003805461080d90612b86565b600081116110d05760405162461bcd60e51b815260206004820152602160248201527f4d696e74696e67203020746f6b656e73206973207175697465207573656c65736044820152607360f81b6064820152608401610905565b60148111156111305760405162461bcd60e51b815260206004820152602660248201527f416d6f756e7420697320686967686572207468616e206d6178696d756d2070656044820152651c8818d85b1b60d21b6064820152608401610905565b61113861155b565b6111795760405162461bcd60e51b815260206004820152601260248201527153616c65206973206e6f742061637469766560701b6044820152606401610905565b3360009081526013602052604090205460ff16156111ea578061119b81612ca7565b9150506000601360006111ab3390565b6001600160a01b031681526020810191909152604001600020805460ff19169115159190911790556111dc33610ef6565b6111ea600f80546001019055565b601154600090610100900460ff161561120657506103e8611216565b61121360326103e8612c3e565b90505b80611220600f5490565b61122a9084612cbe565b111561124057600f5461123d9082612c3e565b91505b6000601054836112509190612cd6565b9050348111156112b15760405162461bcd60e51b815260206004820152602660248201527f50726f7669646564206e6f7420656e6f75676820457468657220666f7220707560448201526572636861736560d01b6064820152608401610905565b60005b838110156112e5576112c533610ef6565b6112d3600f80546001019055565b806112dd81612c55565b9150506112b4565b5080341115610a3b57336112f98234612c3e565b604051600081818185875af1925050503d8060008114611335576040519150601f19603f3d011682016040523d82523d6000602084013e61133a565b606091505b505050505050565b610fef338383611c2f565b611357338361172c565b6113735760405162461bcd60e51b815260040161090590612bc1565b61137f84848484611cfe565b50505050565b6060600d61139283611d31565b600e6040516020016113a693929190612d8f565b6040516020818303038152906040529050919050565b60008181526001602052604081206107f890611e2f565b6113de60003361103e565b6113fa5760405162461bcd60e51b815260040161090590612c70565b60005b818110156114385761142683838381811061141a5761141a612c12565b90506020020135611e39565b8061143081612c55565b9150506113fd565b50818190506012600082825461144e9190612cbe565b90915550505050565b61146260003361103e565b6114ae5760405162461bcd60e51b815260206004820152601d60248201527f43616c6c65722063616e6e6f7420616c7465722077686974654c6973740000006044820152606401610905565b60005b8151811015610fef576001601360008484815181106114d2576114d2612c12565b6020908102919091018101516001600160a01b03168252810191909152604001600020805460ff19169115159190911790558061150e81612c55565b9150506114b1565b610b338282611ee0565b61152b60003361103e565b6115475760405162461bcd60e51b815260040161090590612c70565b6011805460ff19811660ff90911615179055565b601154600090610100900460ff161561158d5760115460ff168015610d2857506103e8611587600f5490565b10905090565b60115460ff168015610d2857506115a760326103e8612c3e565b600f54611587565b600c546001600160a01b031633146116095760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610905565b6001600160a01b03811661166e5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610905565b61167781611a83565b50565b610fef8282611f06565b600061100b836001600160a01b038416611f8a565b60006001600160e01b0319821663780e9d6360e01b14806107f857506107f882611fd9565b600081815260066020526040902080546001600160a01b0319166001600160a01b03841690811790915581906116f382610ca6565b6001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b6000818152600460205260408120546001600160a01b03166117a55760405162461bcd60e51b815260206004820152602c60248201527f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860448201526b34b9ba32b73a103a37b5b2b760a11b6064820152608401610905565b60006117b083610ca6565b9050806001600160a01b0316846001600160a01b031614806117eb5750836001600160a01b03166117e084610890565b6001600160a01b0316145b8061181b57506001600160a01b0380821660009081526007602090815260408083209388168352929052205460ff165b949350505050565b826001600160a01b031661183682610ca6565b6001600160a01b03161461189e5760405162461bcd60e51b815260206004820152602960248201527f4552433732313a207472616e73666572206f6620746f6b656e2074686174206960448201526839903737ba1037bbb760b91b6064820152608401610905565b6001600160a01b0382166119005760405162461bcd60e51b8152602060048201526024808201527f4552433732313a207472616e7366657220746f20746865207a65726f206164646044820152637265737360e01b6064820152608401610905565b61190b838383612019565b6119166000826116be565b6001600160a01b038316600090815260056020526040812080546001929061193f908490612c3e565b90915550506001600160a01b038216600090815260056020526040812080546001929061196d908490612cbe565b909155505060008181526004602052604080822080546001600160a01b0319166001600160a01b0386811691821790925591518493918716917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a4505050565b6000828152602081905260409020600101546119ea8133612024565b610a3b8383611f06565b6001600160a01b0381163314611a645760405162461bcd60e51b815260206004820152602f60248201527f416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e636560448201526e103937b632b9903337b91039b2b63360891b6064820152608401610905565b610fef8282612088565b600061100b836001600160a01b0384166120ed565b600c80546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b6001600160a01b038216611b2b5760405162461bcd60e51b815260206004820181905260248201527f4552433732313a206d696e7420746f20746865207a65726f20616464726573736044820152606401610905565b6000818152600460205260409020546001600160a01b031615611b905760405162461bcd60e51b815260206004820152601c60248201527f4552433732313a20746f6b656e20616c7265616479206d696e746564000000006044820152606401610905565b611b9c60008383612019565b6001600160a01b0382166000908152600560205260408120805460019290611bc5908490612cbe565b909155505060008181526004602052604080822080546001600160a01b0319166001600160a01b03861690811790915590518392907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a45050565b600061100b83836121e0565b816001600160a01b0316836001600160a01b03161415611c915760405162461bcd60e51b815260206004820152601960248201527f4552433732313a20617070726f766520746f2063616c6c6572000000000000006044820152606401610905565b6001600160a01b03838116600081815260076020908152604080832094871680845294825291829020805460ff191686151590811790915591519182527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a3505050565b611d09848484611823565b611d158484848461220a565b61137f5760405162461bcd60e51b815260040161090590612dc2565b606081611d555750506040805180820190915260018152600360fc1b602082015290565b8160005b8115611d7f5780611d6981612c55565b9150611d789050600a83612e2a565b9150611d59565b60008167ffffffffffffffff811115611d9a57611d9a6128d5565b6040519080825280601f01601f191660200182016040528015611dc4576020820181803683370190505b5090505b841561181b57611dd9600183612c3e565b9150611de6600a86612e3e565b611df1906030612cbe565b60f81b818381518110611e0657611e06612c12565b60200101906001600160f81b031916908160001a905350611e28600a86612e2a565b9450611dc8565b60006107f8825490565b6000611e4482610ca6565b9050611e5281600084612019565b611e5d6000836116be565b6001600160a01b0381166000908152600560205260408120805460019290611e86908490612c3e565b909155505060008281526004602052604080822080546001600160a01b0319169055518391906001600160a01b038416907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908390a45050565b600082815260208190526040902060010154611efc8133612024565b610a3b8383612088565b611f10828261103e565b610fef576000828152602081815260408083206001600160a01b03851684529091529020805460ff19166001179055611f463390565b6001600160a01b0316816001600160a01b0316837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45050565b6000818152600183016020526040812054611fd1575081546001818101845560008481526020808220909301849055845484825282860190935260409020919091556107f8565b5060006107f8565b60006001600160e01b031982166380ac58cd60e01b148061200a57506001600160e01b03198216635b5e139f60e01b145b806107f857506107f882612317565b610a3b83838361233c565b61202e828261103e565b610fef57612046816001600160a01b031660146123f4565b6120518360206123f4565b604051602001612062929190612e52565b60408051601f198184030181529082905262461bcd60e51b8252610905916004016127e0565b612092828261103e565b15610fef576000828152602081815260408083206001600160a01b0385168085529252808320805460ff1916905551339285917ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b9190a45050565b600081815260018301602052604081205480156121d6576000612111600183612c3e565b855490915060009061212590600190612c3e565b905081811461218a57600086600001828154811061214557612145612c12565b906000526020600020015490508087600001848154811061216857612168612c12565b6000918252602080832090910192909255918252600188019052604090208390555b855486908061219b5761219b612ec7565b6001900381819060005260206000200160009055905585600101600086815260200190815260200160002060009055600193505050506107f8565b60009150506107f8565b60008260000182815481106121f7576121f7612c12565b9060005260206000200154905092915050565b60006001600160a01b0384163b1561230c57604051630a85bd0160e11b81526001600160a01b0385169063150b7a029061224e903390899088908890600401612edd565b602060405180830381600087803b15801561226857600080fd5b505af1925050508015612298575060408051601f3d908101601f1916820190925261229591810190612f1a565b60015b6122f2573d8080156122c6576040519150601f19603f3d011682016040523d82523d6000602084013e6122cb565b606091505b5080516122ea5760405162461bcd60e51b815260040161090590612dc2565b805181602001fd5b6001600160e01b031916630a85bd0160e11b14905061181b565b506001949350505050565b60006001600160e01b03198216635a05180f60e01b14806107f857506107f882612590565b6001600160a01b0383166123975761239281600a80546000838152600b60205260408120829055600182018355919091527fc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2a80155565b6123ba565b816001600160a01b0316836001600160a01b0316146123ba576123ba83826125c5565b6001600160a01b0382166123d157610a3b81612662565b826001600160a01b0316826001600160a01b031614610a3b57610a3b8282612711565b60606000612403836002612cd6565b61240e906002612cbe565b67ffffffffffffffff811115612426576124266128d5565b6040519080825280601f01601f191660200182016040528015612450576020820181803683370190505b509050600360fc1b8160008151811061246b5761246b612c12565b60200101906001600160f81b031916908160001a905350600f60fb1b8160018151811061249a5761249a612c12565b60200101906001600160f81b031916908160001a90535060006124be846002612cd6565b6124c9906001612cbe565b90505b6001811115612541576f181899199a1a9b1b9c1cb0b131b232b360811b85600f16601081106124fd576124fd612c12565b1a60f81b82828151811061251357612513612c12565b60200101906001600160f81b031916908160001a90535060049490941c9361253a81612ca7565b90506124cc565b50831561100b5760405162461bcd60e51b815260206004820181905260248201527f537472696e67733a20686578206c656e67746820696e73756666696369656e746044820152606401610905565b60006001600160e01b03198216637965db0b60e01b14806107f857506301ffc9a760e01b6001600160e01b03198316146107f8565b600060016125d284610d2d565b6125dc9190612c3e565b60008381526009602052604090205490915080821461262f576001600160a01b03841660009081526008602090815260408083208584528252808320548484528184208190558352600990915290208190555b5060009182526009602090815260408084208490556001600160a01b039094168352600881528383209183525290812055565b600a5460009061267490600190612c3e565b6000838152600b6020526040812054600a805493945090928490811061269c5761269c612c12565b9060005260206000200154905080600a83815481106126bd576126bd612c12565b6000918252602080832090910192909255828152600b9091526040808220849055858252812055600a8054806126f5576126f5612ec7565b6001900381819060005260206000200160009055905550505050565b600061271c83610d2d565b6001600160a01b039093166000908152600860209081526040808320868452825280832085905593825260099052919091209190915550565b6001600160e01b03198116811461167757600080fd5b60006020828403121561277d57600080fd5b813561100b81612755565b60005b838110156127a357818101518382015260200161278b565b8381111561137f5750506000910152565b600081518084526127cc816020860160208601612788565b601f01601f19169290920160200192915050565b60208152600061100b60208301846127b4565b60006020828403121561280557600080fd5b5035919050565b80356001600160a01b038116811461282357600080fd5b919050565b6000806040838503121561283b57600080fd5b6128448361280c565b946020939093013593505050565b60008060006060848603121561286757600080fd5b6128708461280c565b925061287e6020850161280c565b9150604084013590509250925092565b600080604083850312156128a157600080fd5b823591506128b16020840161280c565b90509250929050565b6000602082840312156128cc57600080fd5b61100b8261280c565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f1916810167ffffffffffffffff81118282101715612914576129146128d5565b604052919050565b6000602080838503121561292f57600080fd5b823567ffffffffffffffff8082111561294757600080fd5b818501915085601f83011261295b57600080fd5b81358181111561296d5761296d6128d5565b8060051b915061297e8483016128eb565b818152918301840191848101908884111561299857600080fd5b938501935b838510156129bd576129ae8561280c565b8252938501939085019061299d565b98975050505050505050565b600080604083850312156129dc57600080fd5b50508035926020909101359150565b600080604083850312156129fe57600080fd5b612a078361280c565b915060208301358015158114612a1c57600080fd5b809150509250929050565b60008060008060808587031215612a3d57600080fd5b612a468561280c565b93506020612a5581870161280c565b935060408601359250606086013567ffffffffffffffff80821115612a7957600080fd5b818801915088601f830112612a8d57600080fd5b813581811115612a9f57612a9f6128d5565b612ab1601f8201601f191685016128eb565b91508082528984828501011115612ac757600080fd5b808484018584013760008482840101525080935050505092959194509250565b60008060208385031215612afa57600080fd5b823567ffffffffffffffff80821115612b1257600080fd5b818501915085601f830112612b2657600080fd5b813581811115612b3557600080fd5b8660208260051b8501011115612b4a57600080fd5b60209290920196919550909350505050565b60008060408385031215612b6f57600080fd5b612b788361280c565b91506128b16020840161280c565b600181811c90821680612b9a57607f821691505b60208210811415612bbb57634e487b7160e01b600052602260045260246000fd5b50919050565b60208082526031908201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f6040820152701ddb995c881b9bdc88185c1c1c9bdd9959607a1b606082015260800190565b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052601160045260246000fd5b600082821015612c5057612c50612c28565b500390565b6000600019821415612c6957612c69612c28565b5060010190565b60208082526019908201527f43616c6c65722063616e6e6f7420616c74657220737461746500000000000000604082015260600190565b600081612cb657612cb6612c28565b506000190190565b60008219821115612cd157612cd1612c28565b500190565b6000816000190483118215151615612cf057612cf0612c28565b500290565b8054600090600181811c9080831680612d0f57607f831692505b6020808410821415612d3157634e487b7160e01b600052602260045260246000fd5b818015612d455760018114612d5657612d83565b60ff19861689528489019650612d83565b60008881526020902060005b86811015612d7b5781548b820152908501908301612d62565b505084890196505b50505050505092915050565b6000612d9b8286612cf5565b8451612dab818360208901612788565b612db781830186612cf5565b979650505050505050565b60208082526032908201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560408201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b606082015260800190565b634e487b7160e01b600052601260045260246000fd5b600082612e3957612e39612e14565b500490565b600082612e4d57612e4d612e14565b500690565b7f416363657373436f6e74726f6c3a206163636f756e7420000000000000000000815260008351612e8a816017850160208801612788565b7001034b99036b4b9b9b4b733903937b6329607d1b6017918401918201528351612ebb816028840160208801612788565b01602801949350505050565b634e487b7160e01b600052603160045260246000fd5b6001600160a01b0385811682528416602082015260408101839052608060608201819052600090612f10908301846127b4565b9695505050505050565b600060208284031215612f2c57600080fd5b815161100b8161275556fea26469706673582212200c48bb9e343ee83b115fab6ee3e446e9c8eae067fa4dd5c98713f707d39f12a064736f6c6343000809003368747470733a2f2f6578706f6e656e7469616c732e6172742f6d657461646174612f

Deployed Bytecode

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

Deployed Bytecode Sourcemap

71755:4574:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75930:204;;;;;;;;;;-1:-1:-1;75930:204:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;75930:204:0;;;;;;;;72037:36;;;;;;;;;;;;;;;;;;;738:25:1;;;726:2;711:18;72037:36:0;592:177:1;24480:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;26039:221::-;;;;;;;;;;-1:-1:-1;26039:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1874:32:1;;;1856:51;;1844:2;1829:18;26039:221:0;1710:203:1;25562:411:0;;;;;;;;;;-1:-1:-1;25562:411:0;;;;;:::i;:::-;;:::i;:::-;;38401:113;;;;;;;;;;-1:-1:-1;38489:10:0;:17;38401:113;;72315:36;;;;;;;;;;-1:-1:-1;72315:36:0;;;;;;;;;;;26789:339;;;;;;;;;;-1:-1:-1;26789:339:0;;;;;:::i;:::-;;:::i;49070:123::-;;;;;;;;;;-1:-1:-1;49070:123:0;;;;;:::i;:::-;49136:7;49163:12;;;;;;;;;;:22;;;;49070:123;72167:42;;;;;;;;;;;;72205:4;72167:42;;72124:36;;;;;;;;;;;;72158:2;72124:36;;66851:196;;;;;;;;;;-1:-1:-1;66851:196:0;;;;;:::i;:::-;;:::i;38069:256::-;;;;;;;;;;-1:-1:-1;38069:256:0;;;;;:::i;:::-;;:::i;67436:205::-;;;;;;;;;;-1:-1:-1;67436:205:0;;;;;:::i;:::-;;:::i;73410:178::-;;;;;;;;;;;;;:::i;27199:185::-;;;;;;;;;;-1:-1:-1;27199:185:0;;;;;:::i;:::-;;:::i;38591:233::-;;;;;;;;;;-1:-1:-1;38591:233:0;;;;;:::i;:::-;;:::i;72214:63::-;;;;;;;;;;;;;:::i;24174:239::-;;;;;;;;;;-1:-1:-1;24174:239:0;;;;;:::i;:::-;;:::i;75325:95::-;;;;;;;;;;;;;:::i;23904:208::-;;;;;;;;;;-1:-1:-1;23904:208:0;;;;;:::i;:::-;;:::i;69547:103::-;;;;;;;;;;;;;:::i;73594:366::-;;;;;;;;;;;;;:::i;73147:257::-;;;;;;;;;;-1:-1:-1;73147:257:0;;;;;:::i;:::-;;:::i;68896:87::-;;;;;;;;;;-1:-1:-1;68969:6:0;;-1:-1:-1;;;;;68969:6:0;68896:87;;66306:145;;;;;;;;;;-1:-1:-1;66306:145:0;;;;;:::i;:::-;;:::i;72558:161::-;;;;;;;;;;-1:-1:-1;72558:161:0;;;;;:::i;:::-;;:::i;47955:139::-;;;;;;;;;;-1:-1:-1;47955:139:0;;;;;:::i;:::-;;:::i;24649:104::-;;;;;;;;;;;;;:::i;73966:1085::-;;;;;;:::i;:::-;;:::i;47046:49::-;;;;;;;;;;-1:-1:-1;47046:49:0;47091:4;47046:49;;26332:155;;;;;;;;;;-1:-1:-1;26332:155:0;;;;;:::i;:::-;;:::i;72080:39::-;;;;;;;;;;;;72117:2;72080:39;;72391:49;;;;;;;;;;-1:-1:-1;72391:49:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;27455:328;;;;;;;;;;-1:-1:-1;27455:328:0;;;;;:::i;:::-;;:::i;75690:183::-;;;;;;;;;;-1:-1:-1;75690:183:0;;;;;:::i;:::-;;:::i;66625:134::-;;;;;;;;;;-1:-1:-1;66625:134:0;;;;;:::i;:::-;;:::i;75057:262::-;;;;;;;;;;-1:-1:-1;75057:262:0;;;;;:::i;:::-;;:::i;72890:251::-;;;;;;;;;;-1:-1:-1;72890:251:0;;;;;:::i;:::-;;:::i;67140:201::-;;;;;;;;;;-1:-1:-1;67140:201:0;;;;;:::i;:::-;;:::i;72725:159::-;;;;;;;;;;;;;:::i;72356:28::-;;;;;;;;;;;;;;;;26558:164;;;;;;;;;;-1:-1:-1;26558:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;26679:25:0;;;26655:4;26679:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;26558:164;75426:258;;;;;;;;;;;;;:::i;69805:201::-;;;;;;;;;;-1:-1:-1;69805:201:0;;;;;:::i;:::-;;:::i;75930:204::-;76069:4;76092:36;76116:11;76092:23;:36::i;:::-;76085:43;75930:204;-1:-1:-1;;75930:204:0:o;24480:100::-;24534:13;24567:5;24560:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24480:100;:::o;26039:221::-;26115:7;29382:16;;;:7;:16;;;;;;-1:-1:-1;;;;;29382:16:0;26135:73;;;;-1:-1:-1;;;26135:73:0;;7936:2:1;26135:73:0;;;7918:21:1;7975:2;7955:18;;;7948:30;8014:34;7994:18;;;7987:62;-1:-1:-1;;;8065:18:1;;;8058:42;8117:19;;26135:73:0;;;;;;;;;-1:-1:-1;26228:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;26228:24:0;;26039:221::o;25562:411::-;25643:13;25659:23;25674:7;25659:14;:23::i;:::-;25643:39;;25707:5;-1:-1:-1;;;;;25701:11:0;:2;-1:-1:-1;;;;;25701:11:0;;;25693:57;;;;-1:-1:-1;;;25693:57:0;;8349:2:1;25693:57:0;;;8331:21:1;8388:2;8368:18;;;8361:30;8427:34;8407:18;;;8400:62;-1:-1:-1;;;8478:18:1;;;8471:31;8519:19;;25693:57:0;8147:397:1;25693:57:0;1560:10;-1:-1:-1;;;;;25785:21:0;;;;:62;;-1:-1:-1;25810:37:0;25827:5;1560:10;26558:164;:::i;25810:37::-;25763:168;;;;-1:-1:-1;;;25763:168:0;;8751:2:1;25763:168:0;;;8733:21:1;8790:2;8770:18;;;8763:30;8829:34;8809:18;;;8802:62;8900:26;8880:18;;;8873:54;8944:19;;25763:168:0;8549:420:1;25763:168:0;25944:21;25953:2;25957:7;25944:8;:21::i;:::-;25632:341;25562:411;;:::o;26789:339::-;26984:41;1560:10;27017:7;26984:18;:41::i;:::-;26976:103;;;;-1:-1:-1;;;26976:103:0;;;;;;;:::i;:::-;27092:28;27102:4;27108:2;27112:7;27092:9;:28::i;66851:196::-;66967:30;66983:4;66989:7;66967:15;:30::i;:::-;67008:18;;;;:12;:18;;;;;:31;;67031:7;67008:22;:31::i;38069:256::-;38166:7;38202:23;38219:5;38202:16;:23::i;:::-;38194:5;:31;38186:87;;;;-1:-1:-1;;;38186:87:0;;9594:2:1;38186:87:0;;;9576:21:1;9633:2;9613:18;;;9606:30;9672:34;9652:18;;;9645:62;-1:-1:-1;;;9723:18:1;;;9716:41;9774:19;;38186:87:0;9392:407:1;38186:87:0;-1:-1:-1;;;;;;38291:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;38069:256::o;67436:205::-;67555:33;67574:4;67580:7;67555:18;:33::i;:::-;67599:18;;;;:12;:18;;;;;:34;;67625:7;67599:25;:34::i;73410:178::-;73452:41;47091:4;1560:10;47955:139;:::i;73452:41::-;73444:76;;;;-1:-1:-1;;;73444:76:0;;10006:2:1;73444:76:0;;;9988:21:1;10045:2;10025:18;;;10018:30;-1:-1:-1;;;10064:18:1;;;10057:52;10126:18;;73444:76:0;9804:346:1;73444:76:0;68969:6;;73527:55;;-1:-1:-1;;;;;68969:6:0;;;;73556:21;;73527:55;;;;73556:21;68969:6;73527:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25632:341;25562:411;;:::o;27199:185::-;27337:39;27354:4;27360:2;27364:7;27337:39;;;;;;;;;;;;:16;:39::i;38591:233::-;38666:7;38702:30;38489:10;:17;;38401:113;38702:30;38694:5;:38;38686:95;;;;-1:-1:-1;;;38686:95:0;;10567:2:1;38686:95:0;;;10549:21:1;10606:2;10586:18;;;10579:30;10645:34;10625:18;;;10618:62;-1:-1:-1;;;10696:18:1;;;10689:42;10748:19;;38686:95:0;10365:408:1;38686:95:0;38799:10;38810:5;38799:17;;;;;;;;:::i;:::-;;;;;;;;;38792:24;;38591:233;;;:::o;72214:63::-;72250:27;72158:2;72205:4;72250:27;:::i;:::-;72214:63;:::o;24174:239::-;24246:7;24282:16;;;:7;:16;;;;;;-1:-1:-1;;;;;24282:16:0;24317:19;24309:73;;;;-1:-1:-1;;;24309:73:0;;11374:2:1;24309:73:0;;;11356:21:1;11413:2;11393:18;;;11386:30;11452:34;11432:18;;;11425:62;-1:-1:-1;;;11503:18:1;;;11496:39;11552:19;;24309:73:0;11172:405:1;75325:95:0;75369:4;75389:25;:15;71250:14;;71158:114;75389:25;75382:32;;75325:95;:::o;23904:208::-;23976:7;-1:-1:-1;;;;;24004:19:0;;23996:74;;;;-1:-1:-1;;;23996:74:0;;11784:2:1;23996:74:0;;;11766:21:1;11823:2;11803:18;;;11796:30;11862:34;11842:18;;;11835:62;-1:-1:-1;;;11913:18:1;;;11906:40;11963:19;;23996:74:0;11582:406:1;23996:74:0;-1:-1:-1;;;;;;24088:16:0;;;;;:9;:16;;;;;;;23904:208::o;69547:103::-;68969:6;;-1:-1:-1;;;;;68969:6:0;1560:10;69116:23;69108:68;;;;-1:-1:-1;;;69108:68:0;;12195:2:1;69108:68:0;;;12177:21:1;;;12214:18;;;12207:30;12273:34;12253:18;;;12246:62;12325:18;;69108:68:0;11993:356:1;69108:68:0;69612:30:::1;69639:1;69612:18;:30::i;:::-;69547:103::o:0;73594:366::-;73641:41;47091:4;1560:10;47955:139;:::i;73641:41::-;73633:84;;;;-1:-1:-1;;;73633:84:0;;12556:2:1;73633:84:0;;;12538:21:1;12595:2;12575:18;;;12568:30;12634:32;12614:18;;;12607:60;12684:18;;73633:84:0;12354:354:1;73633:84:0;73733:16;;;;;;;73732:17;73724:66;;;;-1:-1:-1;;;73724:66:0;;12915:2:1;73724:66:0;;;12897:21:1;12954:2;12934:18;;;12927:30;12993:34;12973:18;;;12966:62;-1:-1:-1;;;13044:18:1;;;13037:34;13088:19;;73724:66:0;12713:400:1;73724:66:0;73802:6;73797:128;72158:2;73812:1;:12;73797:128;;;73840:41;73846:7;68969:6;;-1:-1:-1;;;;;68969:6:0;;68896:87;73846:7;73855:15;71250:14;73840:5;:41::i;:::-;73890:27;:15;71369:19;;71387:1;71369:19;;;71280:127;73890:27;73826:3;;;;:::i;:::-;;;;73797:128;;;-1:-1:-1;73931:16:0;:23;;-1:-1:-1;;73931:23:0;;;;;73594:366::o;73147:257::-;73230:41;47091:4;1560:10;47955:139;:::i;73230:41::-;73222:83;;;;-1:-1:-1;;;73222:83:0;;13460:2:1;73222:83:0;;;13442:21:1;13499:2;13479:18;;;13472:30;13538:31;13518:18;;;13511:59;13587:18;;73222:83:0;13258:353:1;73222:83:0;73316:6;73312:87;73328:5;:12;73326:1;:14;73312:87;;;73386:5;73356:17;:27;73374:5;73380:1;73374:8;;;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;73356:27:0;;;;;;;;;;;-1:-1:-1;73356:27:0;:35;;-1:-1:-1;;73356:35:0;;;;;;;;;;73342:3;;;;:::i;:::-;;;;73312:87;;;;73147:257;:::o;66306:145::-;66388:7;66415:18;;;:12;:18;;;;;:28;;66437:5;66415:21;:28::i;:::-;66408:35;66306:145;-1:-1:-1;;;66306:145:0:o;72558:161::-;72613:41;47091:4;1560:10;47955:139;:::i;72613:41::-;72605:79;;;;-1:-1:-1;;;72605:79:0;;;;;;;:::i;:::-;72691:11;:22;72558:161::o;47955:139::-;48033:4;48057:12;;;;;;;;;;;-1:-1:-1;;;;;48057:29:0;;;;;;;;;;;;;;;47955:139::o;24649:104::-;24705:13;24738:7;24731:14;;;;;:::i;73966:1085::-;74034:1;74024:7;:11;74016:57;;;;-1:-1:-1;;;74016:57:0;;14172:2:1;74016:57:0;;;14154:21:1;14211:2;14191:18;;;14184:30;14250:34;14230:18;;;14223:62;-1:-1:-1;;;14301:18:1;;;14294:31;14342:19;;74016:57:0;13970:397:1;74016:57:0;72117:2;74088:7;:24;;74080:75;;;;-1:-1:-1;;;74080:75:0;;14574:2:1;74080:75:0;;;14556:21:1;14613:2;14593:18;;;14586:30;14652:34;14632:18;;;14625:62;-1:-1:-1;;;14703:18:1;;;14696:36;14749:19;;74080:75:0;14372:402:1;74080:75:0;74170:14;:12;:14::i;:::-;74162:45;;;;-1:-1:-1;;;74162:45:0;;14981:2:1;74162:45:0;;;14963:21:1;15020:2;15000:18;;;14993:30;-1:-1:-1;;;15039:18:1;;;15032:48;15097:18;;74162:45:0;14779:342:1;74162:45:0;1560:10;74220:31;;;;:17;:31;;;;;;;;74216:202;;;74262:9;;;;:::i;:::-;;;;74314:5;74280:17;:31;74298:12;1560:10;;1480:98;74298:12;-1:-1:-1;;;;;74280:31:0;;;;;;;;;;;;-1:-1:-1;74280:31:0;:39;;-1:-1:-1;;74280:39:0;;;;;;;;;;74328:46;1560:10;74334:12;1480:98;74328:46;74383:27;:15;71369:19;;71387:1;71369:19;;;71280:127;74383:27;74448:16;;74426:10;;74448:16;;;;;74444:110;;;-1:-1:-1;72205:4:0;74444:110;;;72250:27;72158:2;72205:4;72250:27;:::i;:::-;74526:20;;74444:110;74602:5;74574:25;:15;71250:14;;71158:114;74574:25;74566:33;;:7;:33;:::i;:::-;:41;74562:105;;;74634:15;71250:14;74628:31;;:5;:31;:::i;:::-;74618:41;;74562:105;74675:16;74702:11;;74694:7;:19;;;;:::i;:::-;74675:38;;74743:9;74728:11;:24;;74720:75;;;;-1:-1:-1;;;74720:75:0;;15775:2:1;74720:75:0;;;15757:21:1;15814:2;15794:18;;;15787:30;15853:34;15833:18;;;15826:62;-1:-1:-1;;;15904:18:1;;;15897:36;15950:19;;74720:75:0;15573:402:1;74720:75:0;74807:6;74802:130;74819:7;74817:1;:9;74802:130;;;74842:46;1560:10;74848:12;1480:98;74842:46;74897:27;:15;71369:19;;71387:1;71369:19;;;71280:127;74897:27;74828:3;;;;:::i;:::-;;;;74802:130;;;;74954:11;74942:9;:23;74938:108;;;1560:10;75010:23;75022:11;75010:9;:23;:::i;:::-;74976:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74009:1042;;73966:1085;:::o;26332:155::-;26427:52;1560:10;26460:8;26470;26427:18;:52::i;27455:328::-;27630:41;1560:10;27663:7;27630:18;:41::i;:::-;27622:103;;;;-1:-1:-1;;;27622:103:0;;;;;;;:::i;:::-;27736:39;27750:4;27756:2;27760:7;27769:5;27736:13;:39::i;:::-;27455:328;;;;:::o;75690:183::-;75756:13;75809;75824:26;75841:8;75824:16;:26::i;:::-;75852:13;75792:74;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;75778:89;;75690:183;;;:::o;66625:134::-;66697:7;66724:18;;;:12;:18;;;;;:27;;:25;:27::i;75057:262::-;75126:41;47091:4;1560:10;47955:139;:::i;75126:41::-;75118:79;;;;-1:-1:-1;;;75118:79:0;;;;;;;:::i;:::-;75209:6;75204:72;75217:17;;;75204:72;;;75250:18;75256:8;;75265:1;75256:11;;;;;;;:::i;:::-;;;;;;;75250:5;:18::i;:::-;75236:3;;;;:::i;:::-;;;;75204:72;;;;75298:8;;:15;;75282:12;;:31;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;75057:262:0:o;72890:251::-;72968:41;47091:4;1560:10;47955:139;:::i;72968:41::-;72960:83;;;;-1:-1:-1;;;72960:83:0;;13460:2:1;72960:83:0;;;13442:21:1;13499:2;13479:18;;;13472:30;13538:31;13518:18;;;13511:59;13587:18;;72960:83:0;13258:353:1;72960:83:0;73054:6;73050:86;73066:5;:12;73064:1;:14;73050:86;;;73124:4;73094:17;:27;73112:5;73118:1;73112:8;;;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;73094:27:0;;;;;;;;;;;-1:-1:-1;73094:27:0;:34;;-1:-1:-1;;73094:34:0;;;;;;;;;;73080:3;;;;:::i;:::-;;;;73050:86;;67140:201;67257:31;67274:4;67280:7;67257:16;:31::i;72725:159::-;72774:41;47091:4;1560:10;47955:139;:::i;72774:41::-;72766:79;;;;-1:-1:-1;;;72766:79:0;;;;;;;:::i;:::-;72867:11;;;-1:-1:-1;;72852:26:0;;72867:11;;;;72866:12;72852:26;;;72725:159::o;75426:258::-;75486:16;;75470:4;;75486:16;;;;;75482:197;;;75521:11;;;;:57;;;;;72205:4;75536:25;:15;71250:14;;71158:114;75536:25;:42;75513:66;;75426:258;:::o;75482:197::-;75615:11;;;;:55;;;;-1:-1:-1;72250:27:0;72158:2;72205:4;72250:27;:::i;:::-;75630:15;71250:14;75630:25;71158:114;69805:201;68969:6;;-1:-1:-1;;;;;68969:6:0;1560:10;69116:23;69108:68;;;;-1:-1:-1;;;69108:68:0;;12195:2:1;69108:68:0;;;12177:21:1;;;12214:18;;;12207:30;12273:34;12253:18;;;12246:62;12325:18;;69108:68:0;11993:356:1;69108:68:0;-1:-1:-1;;;;;69894:22:0;::::1;69886:73;;;::::0;-1:-1:-1;;;69886:73:0;;17747:2:1;69886:73:0::1;::::0;::::1;17729:21:1::0;17786:2;17766:18;;;17759:30;17825:34;17805:18;;;17798:62;-1:-1:-1;;;17876:18:1;;;17869:36;17922:19;;69886:73:0::1;17545:402:1::0;69886:73:0::1;69970:28;69989:8;69970:18;:28::i;:::-;69805:201:::0;:::o;51380:112::-;51459:25;51470:4;51476:7;51459:10;:25::i;60401:152::-;60471:4;60495:50;60500:3;-1:-1:-1;;;;;60520:23:0;;60495:4;:50::i;37761:224::-;37863:4;-1:-1:-1;;;;;;37887:50:0;;-1:-1:-1;;;37887:50:0;;:90;;;37941:36;37965:11;37941:23;:36::i;33275:174::-;33350:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;33350:29:0;-1:-1:-1;;;;;33350:29:0;;;;;;;;:24;;33404:23;33350:24;33404:14;:23::i;:::-;-1:-1:-1;;;;;33395:46:0;;;;;;;;;;;33275:174;;:::o;29587:348::-;29680:4;29382:16;;;:7;:16;;;;;;-1:-1:-1;;;;;29382:16:0;29697:73;;;;-1:-1:-1;;;29697:73:0;;18154:2:1;29697:73:0;;;18136:21:1;18193:2;18173:18;;;18166:30;18232:34;18212:18;;;18205:62;-1:-1:-1;;;18283:18:1;;;18276:42;18335:19;;29697:73:0;17952:408:1;29697:73:0;29781:13;29797:23;29812:7;29797:14;:23::i;:::-;29781:39;;29850:5;-1:-1:-1;;;;;29839:16:0;:7;-1:-1:-1;;;;;29839:16:0;;:51;;;;29883:7;-1:-1:-1;;;;;29859:31:0;:20;29871:7;29859:11;:20::i;:::-;-1:-1:-1;;;;;29859:31:0;;29839:51;:87;;;-1:-1:-1;;;;;;26679:25:0;;;26655:4;26679:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;29894:32;29831:96;29587:348;-1:-1:-1;;;;29587:348:0:o;32579:578::-;32738:4;-1:-1:-1;;;;;32711:31:0;:23;32726:7;32711:14;:23::i;:::-;-1:-1:-1;;;;;32711:31:0;;32703:85;;;;-1:-1:-1;;;32703:85:0;;18567:2:1;32703:85:0;;;18549:21:1;18606:2;18586:18;;;18579:30;18645:34;18625:18;;;18618:62;-1:-1:-1;;;18696:18:1;;;18689:39;18745:19;;32703:85:0;18365:405:1;32703:85:0;-1:-1:-1;;;;;32807:16:0;;32799:65;;;;-1:-1:-1;;;32799:65:0;;18977:2:1;32799:65:0;;;18959:21:1;19016:2;18996:18;;;18989:30;19055:34;19035:18;;;19028:62;-1:-1:-1;;;19106:18:1;;;19099:34;19150:19;;32799:65:0;18775:400:1;32799:65:0;32877:39;32898:4;32904:2;32908:7;32877:20;:39::i;:::-;32981:29;32998:1;33002:7;32981:8;:29::i;:::-;-1:-1:-1;;;;;33023:15:0;;;;;;:9;:15;;;;;:20;;33042:1;;33023:15;:20;;33042:1;;33023:20;:::i;:::-;;;;-1:-1:-1;;;;;;;33054:13:0;;;;;;:9;:13;;;;;:18;;33071:1;;33054:13;:18;;33071:1;;33054:18;:::i;:::-;;;;-1:-1:-1;;33083:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;33083:21:0;-1:-1:-1;;;;;33083:21:0;;;;;;;;;33122:27;;33083:16;;33122:27;;;;;;;32579:578;;;:::o;49455:147::-;49136:7;49163:12;;;;;;;;;;:22;;;47537:30;47548:4;1560:10;47537;:30::i;:::-;49569:25:::1;49580:4;49586:7;49569:10;:25::i;50503:218::-:0;-1:-1:-1;;;;;50599:23:0;;1560:10;50599:23;50591:83;;;;-1:-1:-1;;;50591:83:0;;19382:2:1;50591:83:0;;;19364:21:1;19421:2;19401:18;;;19394:30;19460:34;19440:18;;;19433:62;-1:-1:-1;;;19511:18:1;;;19504:45;19566:19;;50591:83:0;19180:411:1;50591:83:0;50687:26;50699:4;50705:7;50687:11;:26::i;60729:158::-;60802:4;60826:53;60834:3;-1:-1:-1;;;;;60854:23:0;;60826:7;:53::i;70166:191::-;70259:6;;;-1:-1:-1;;;;;70276:17:0;;;-1:-1:-1;;;;;;70276:17:0;;;;;;;70309:40;;70259:6;;;70276:17;70259:6;;70309:40;;70240:16;;70309:40;70229:128;70166:191;:::o;31271:382::-;-1:-1:-1;;;;;31351:16:0;;31343:61;;;;-1:-1:-1;;;31343:61:0;;19798:2:1;31343:61:0;;;19780:21:1;;;19817:18;;;19810:30;19876:34;19856:18;;;19849:62;19928:18;;31343:61:0;19596:356:1;31343:61:0;29358:4;29382:16;;;:7;:16;;;;;;-1:-1:-1;;;;;29382:16:0;:30;31415:58;;;;-1:-1:-1;;;31415:58:0;;20159:2:1;31415:58:0;;;20141:21:1;20198:2;20178:18;;;20171:30;20237;20217:18;;;20210:58;20285:18;;31415:58:0;19957:352:1;31415:58:0;31486:45;31515:1;31519:2;31523:7;31486:20;:45::i;:::-;-1:-1:-1;;;;;31544:13:0;;;;;;:9;:13;;;;;:18;;31561:1;;31544:13;:18;;31561:1;;31544:18;:::i;:::-;;;;-1:-1:-1;;31573:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;31573:21:0;-1:-1:-1;;;;;31573:21:0;;;;;;;;31612:33;;31573:16;;;31612:33;;31573:16;;31612:33;31271:382;;:::o;61697:158::-;61771:7;61822:22;61826:3;61838:5;61822:3;:22::i;33591:315::-;33746:8;-1:-1:-1;;;;;33737:17:0;:5;-1:-1:-1;;;;;33737:17:0;;;33729:55;;;;-1:-1:-1;;;33729:55:0;;20516:2:1;33729:55:0;;;20498:21:1;20555:2;20535:18;;;20528:30;20594:27;20574:18;;;20567:55;20639:18;;33729:55:0;20314:349:1;33729:55:0;-1:-1:-1;;;;;33795:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;33795:46:0;;;;;;;;;;33857:41;;540::1;;;33857::0;;513:18:1;33857:41:0;;;;;;;33591:315;;;:::o;28665:::-;28822:28;28832:4;28838:2;28842:7;28822:9;:28::i;:::-;28869:48;28892:4;28898:2;28902:7;28911:5;28869:22;:48::i;:::-;28861:111;;;;-1:-1:-1;;;28861:111:0;;;;;;;:::i;2919:723::-;2975:13;3196:10;3192:53;;-1:-1:-1;;3223:10:0;;;;;;;;;;;;-1:-1:-1;;;3223:10:0;;;;;2919:723::o;3192:53::-;3270:5;3255:12;3311:78;3318:9;;3311:78;;3344:8;;;;:::i;:::-;;-1:-1:-1;3367:10:0;;-1:-1:-1;3375:2:0;3367:10;;:::i;:::-;;;3311:78;;;3399:19;3431:6;3421:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3421:17:0;;3399:39;;3449:154;3456:10;;3449:154;;3483:11;3493:1;3483:11;;:::i;:::-;;-1:-1:-1;3552:10:0;3560:2;3552:5;:10;:::i;:::-;3539:24;;:2;:24;:::i;:::-;3526:39;;3509:6;3516;3509:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;3509:56:0;;;;;;;;-1:-1:-1;3580:11:0;3589:2;3580:11;;:::i;:::-;;;3449:154;;61226:117;61289:7;61316:19;61324:3;56710:18;;56627:109;31882:360;31942:13;31958:23;31973:7;31958:14;:23::i;:::-;31942:39;;31994:48;32015:5;32030:1;32034:7;31994:20;:48::i;:::-;32083:29;32100:1;32104:7;32083:8;:29::i;:::-;-1:-1:-1;;;;;32125:16:0;;;;;;:9;:16;;;;;:21;;32145:1;;32125:16;:21;;32145:1;;32125:21;:::i;:::-;;;;-1:-1:-1;;32164:16:0;;;;:7;:16;;;;;;32157:23;;-1:-1:-1;;;;;;32157:23:0;;;32198:36;32172:7;;32164:16;-1:-1:-1;;;;;32198:36:0;;;;;32164:16;;32198:36;31931:311;31882:360;:::o;49847:149::-;49136:7;49163:12;;;;;;;;;;:22;;;47537:30;47548:4;1560:10;47537;:30::i;:::-;49962:26:::1;49974:4;49980:7;49962:11;:26::i;52004:238::-:0;52088:22;52096:4;52102:7;52088;:22::i;:::-;52083:152;;52127:6;:12;;;;;;;;;;;-1:-1:-1;;;;;52127:29:0;;;;;;;;;:36;;-1:-1:-1;;52127:36:0;52159:4;52127:36;;;52210:12;1560:10;;1480:98;52210:12;-1:-1:-1;;;;;52183:40:0;52201:7;-1:-1:-1;;;;;52183:40:0;52195:4;52183:40;;;;;;;;;;52004:238;;:::o;54316:414::-;54379:4;56509:19;;;:12;;;:19;;;;;;54396:327;;-1:-1:-1;54439:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;54622:18;;54600:19;;;:12;;;:19;;;;;;:40;;;;54655:11;;54396:327;-1:-1:-1;54706:5:0;54699:12;;23535:305;23637:4;-1:-1:-1;;;;;;23674:40:0;;-1:-1:-1;;;23674:40:0;;:105;;-1:-1:-1;;;;;;;23731:48:0;;-1:-1:-1;;;23731:48:0;23674:105;:158;;;;23796:36;23820:11;23796:23;:36::i;76140:184::-;76273:45;76300:4;76306:2;76310:7;76273:26;:45::i;48384:497::-;48465:22;48473:4;48479:7;48465;:22::i;:::-;48460:414;;48653:41;48681:7;-1:-1:-1;;;;;48653:41:0;48691:2;48653:19;:41::i;:::-;48767:38;48795:4;48802:2;48767:19;:38::i;:::-;48558:270;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;48558:270:0;;;;;;;;;;-1:-1:-1;;;48504:358:0;;;;;;;:::i;52374:239::-;52458:22;52466:4;52472:7;52458;:22::i;:::-;52454:152;;;52529:5;52497:12;;;;;;;;;;;-1:-1:-1;;;;;52497:29:0;;;;;;;;;;:37;;-1:-1:-1;;52497:37:0;;;52554:40;1560:10;;52497:12;;52554:40;;52529:5;52554:40;52374:239;;:::o;54906:1420::-;54972:4;55111:19;;;:12;;;:19;;;;;;55147:15;;55143:1176;;55522:21;55546:14;55559:1;55546:10;:14;:::i;:::-;55595:18;;55522:38;;-1:-1:-1;55575:17:0;;55595:22;;55616:1;;55595:22;:::i;:::-;55575:42;;55651:13;55638:9;:26;55634:405;;55685:17;55705:3;:11;;55717:9;55705:22;;;;;;;;:::i;:::-;;;;;;;;;55685:42;;55859:9;55830:3;:11;;55842:13;55830:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;55944:23;;;:12;;;:23;;;;;:36;;;55634:405;56120:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;56215:3;:12;;:19;56228:5;56215:19;;;;;;;;;;;56208:26;;;56258:4;56251:11;;;;;;;55143:1176;56302:5;56295:12;;;;;57090:120;57157:7;57184:3;:11;;57196:5;57184:18;;;;;;;;:::i;:::-;;;;;;;;;57177:25;;57090:120;;;;:::o;34471:799::-;34626:4;-1:-1:-1;;;;;34647:13:0;;15292:20;15340:8;34643:620;;34683:72;;-1:-1:-1;;;34683:72:0;;-1:-1:-1;;;;;34683:36:0;;;;;:72;;1560:10;;34734:4;;34740:7;;34749:5;;34683:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;34683:72:0;;;;;;;;-1:-1:-1;;34683:72:0;;;;;;;;;;;;:::i;:::-;;;34679:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;34925:13:0;;34921:272;;34968:60;;-1:-1:-1;;;34968:60:0;;;;;;;:::i;34921:272::-;35143:6;35137:13;35128:6;35124:2;35120:15;35113:38;34679:529;-1:-1:-1;;;;;;34806:51:0;-1:-1:-1;;;34806:51:0;;-1:-1:-1;34799:58:0;;34643:620;-1:-1:-1;35247:4:0;34471:799;;;;;;:::o;65493:214::-;65578:4;-1:-1:-1;;;;;;65602:57:0;;-1:-1:-1;;;65602:57:0;;:97;;;65663:36;65687:11;65663:23;:36::i;39437:589::-;-1:-1:-1;;;;;39643:18:0;;39639:187;;39678:40;39710:7;40853:10;:17;;40826:24;;;;:15;:24;;;;;:44;;;40881:24;;;;;;;;;;;;40749:164;39678:40;39639:187;;;39748:2;-1:-1:-1;;;;;39740:10:0;:4;-1:-1:-1;;;;;39740:10:0;;39736:90;;39767:47;39800:4;39806:7;39767:32;:47::i;:::-;-1:-1:-1;;;;;39840:16:0;;39836:183;;39873:45;39910:7;39873:36;:45::i;39836:183::-;39946:4;-1:-1:-1;;;;;39940:10:0;:2;-1:-1:-1;;;;;39940:10:0;;39936:83;;39967:40;39995:2;39999:7;39967:27;:40::i;4220:451::-;4295:13;4321:19;4353:10;4357:6;4353:1;:10;:::i;:::-;:14;;4366:1;4353:14;:::i;:::-;4343:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4343:25:0;;4321:47;;-1:-1:-1;;;4379:6:0;4386:1;4379:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;4379:15:0;;;;;;;;;-1:-1:-1;;;4405:6:0;4412:1;4405:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;4405:15:0;;;;;;;;-1:-1:-1;4436:9:0;4448:10;4452:6;4448:1;:10;:::i;:::-;:14;;4461:1;4448:14;:::i;:::-;4436:26;;4431:135;4468:1;4464;:5;4431:135;;;-1:-1:-1;;;4516:5:0;4524:3;4516:11;4503:25;;;;;;;:::i;:::-;;;;4491:6;4498:1;4491:9;;;;;;;;:::i;:::-;;;;:37;-1:-1:-1;;;;;4491:37:0;;;;;;;;-1:-1:-1;4553:1:0;4543:11;;;;;4471:3;;;:::i;:::-;;;4431:135;;;-1:-1:-1;4584:10:0;;4576:55;;;;-1:-1:-1;;;4576:55:0;;23334:2:1;4576:55:0;;;23316:21:1;;;23353:18;;;23346:30;23412:34;23392:18;;;23385:62;23464:18;;4576:55:0;23132:356:1;47659:204:0;47744:4;-1:-1:-1;;;;;;47768:47:0;;-1:-1:-1;;;47768:47:0;;:87;;-1:-1:-1;;;;;;;;;;2578:40:0;;;47819:36;2469:157;41540:988;41806:22;41856:1;41831:22;41848:4;41831:16;:22::i;:::-;:26;;;;:::i;:::-;41868:18;41889:26;;;:17;:26;;;;;;41806:51;;-1:-1:-1;42022:28:0;;;42018:328;;-1:-1:-1;;;;;42089:18:0;;42067:19;42089:18;;;:12;:18;;;;;;;;:34;;;;;;;;;42140:30;;;;;;:44;;;42257:30;;:17;:30;;;;;:43;;;42018:328;-1:-1:-1;42442:26:0;;;;:17;:26;;;;;;;;42435:33;;;-1:-1:-1;;;;;42486:18:0;;;;;:12;:18;;;;;:34;;;;;;;42479:41;41540:988::o;42823:1079::-;43101:10;:17;43076:22;;43101:21;;43121:1;;43101:21;:::i;:::-;43133:18;43154:24;;;:15;:24;;;;;;43527:10;:26;;43076:46;;-1:-1:-1;43154:24:0;;43076:46;;43527:26;;;;;;:::i;:::-;;;;;;;;;43505:48;;43591:11;43566:10;43577;43566:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;43671:28;;;:15;:28;;;;;;;:41;;;43843:24;;;;;43836:31;43878:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;42894:1008;;;42823:1079;:::o;40327:221::-;40412:14;40429:20;40446:2;40429:16;:20::i;:::-;-1:-1:-1;;;;;40460:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;40505:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;40327:221:0: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;774:258::-;846:1;856:113;870:6;867:1;864:13;856:113;;;946:11;;;940:18;927:11;;;920:39;892:2;885:10;856:113;;;987:6;984:1;981:13;978:48;;;-1:-1:-1;;1022:1:1;1004:16;;997:27;774:258::o;1037:::-;1079:3;1117:5;1111:12;1144:6;1139:3;1132:19;1160:63;1216:6;1209:4;1204:3;1200:14;1193:4;1186:5;1182:16;1160:63;:::i;:::-;1277:2;1256:15;-1:-1:-1;;1252:29:1;1243:39;;;;1284:4;1239:50;;1037:258;-1:-1:-1;;1037:258:1:o;1300:220::-;1449:2;1438:9;1431:21;1412:4;1469:45;1510:2;1499:9;1495:18;1487:6;1469:45;:::i;1525:180::-;1584:6;1637:2;1625:9;1616:7;1612:23;1608:32;1605:52;;;1653:1;1650;1643:12;1605:52;-1:-1:-1;1676:23:1;;1525:180;-1:-1:-1;1525:180:1:o;1918:173::-;1986:20;;-1:-1:-1;;;;;2035:31:1;;2025:42;;2015:70;;2081:1;2078;2071:12;2015:70;1918:173;;;:::o;2096:254::-;2164:6;2172;2225:2;2213:9;2204:7;2200:23;2196:32;2193:52;;;2241:1;2238;2231:12;2193:52;2264:29;2283:9;2264:29;:::i;:::-;2254:39;2340:2;2325:18;;;;2312:32;;-1:-1:-1;;;2096:254:1:o;2355:328::-;2432:6;2440;2448;2501:2;2489:9;2480:7;2476:23;2472:32;2469:52;;;2517:1;2514;2507:12;2469:52;2540:29;2559:9;2540:29;:::i;:::-;2530:39;;2588:38;2622:2;2611:9;2607:18;2588:38;:::i;:::-;2578:48;;2673:2;2662:9;2658:18;2645:32;2635:42;;2355:328;;;;;:::o;3055:254::-;3123:6;3131;3184:2;3172:9;3163:7;3159:23;3155:32;3152:52;;;3200:1;3197;3190:12;3152:52;3236:9;3223:23;3213:33;;3265:38;3299:2;3288:9;3284:18;3265:38;:::i;:::-;3255:48;;3055:254;;;;;:::o;3314:186::-;3373:6;3426:2;3414:9;3405:7;3401:23;3397:32;3394:52;;;3442:1;3439;3432:12;3394:52;3465:29;3484:9;3465:29;:::i;3505:127::-;3566:10;3561:3;3557:20;3554:1;3547:31;3597:4;3594:1;3587:15;3621:4;3618:1;3611:15;3637:275;3708:2;3702:9;3773:2;3754:13;;-1:-1:-1;;3750:27:1;3738:40;;3808:18;3793:34;;3829:22;;;3790:62;3787:88;;;3855:18;;:::i;:::-;3891:2;3884:22;3637:275;;-1:-1:-1;3637:275:1:o;3917:952::-;4001:6;4032:2;4075;4063:9;4054:7;4050:23;4046:32;4043:52;;;4091:1;4088;4081:12;4043:52;4131:9;4118:23;4160:18;4201:2;4193:6;4190:14;4187:34;;;4217:1;4214;4207:12;4187:34;4255:6;4244:9;4240:22;4230:32;;4300:7;4293:4;4289:2;4285:13;4281:27;4271:55;;4322:1;4319;4312:12;4271:55;4358:2;4345:16;4380:2;4376;4373:10;4370:36;;;4386:18;;:::i;:::-;4432:2;4429:1;4425:10;4415:20;;4455:28;4479:2;4475;4471:11;4455:28;:::i;:::-;4517:15;;;4587:11;;;4583:20;;;4548:12;;;;4615:19;;;4612:39;;;4647:1;4644;4637:12;4612:39;4671:11;;;;4691:148;4707:6;4702:3;4699:15;4691:148;;;4773:23;4792:3;4773:23;:::i;:::-;4761:36;;4724:12;;;;4817;;;;4691:148;;;4858:5;3917:952;-1:-1:-1;;;;;;;;3917:952:1:o;4874:248::-;4942:6;4950;5003:2;4991:9;4982:7;4978:23;4974:32;4971:52;;;5019:1;5016;5009:12;4971:52;-1:-1:-1;;5042:23:1;;;5112:2;5097:18;;;5084:32;;-1:-1:-1;4874:248:1:o;5127:347::-;5192:6;5200;5253:2;5241:9;5232:7;5228:23;5224:32;5221:52;;;5269:1;5266;5259:12;5221:52;5292:29;5311:9;5292:29;:::i;:::-;5282:39;;5371:2;5360:9;5356:18;5343:32;5418:5;5411:13;5404:21;5397:5;5394:32;5384:60;;5440:1;5437;5430:12;5384:60;5463:5;5453:15;;;5127:347;;;;;:::o;5479:980::-;5574:6;5582;5590;5598;5651:3;5639:9;5630:7;5626:23;5622:33;5619:53;;;5668:1;5665;5658:12;5619:53;5691:29;5710:9;5691:29;:::i;:::-;5681:39;;5739:2;5760:38;5794:2;5783:9;5779:18;5760:38;:::i;:::-;5750:48;;5845:2;5834:9;5830:18;5817:32;5807:42;;5900:2;5889:9;5885:18;5872:32;5923:18;5964:2;5956:6;5953:14;5950:34;;;5980:1;5977;5970:12;5950:34;6018:6;6007:9;6003:22;5993:32;;6063:7;6056:4;6052:2;6048:13;6044:27;6034:55;;6085:1;6082;6075:12;6034:55;6121:2;6108:16;6143:2;6139;6136:10;6133:36;;;6149:18;;:::i;:::-;6191:53;6234:2;6215:13;;-1:-1:-1;;6211:27:1;6207:36;;6191:53;:::i;:::-;6178:66;;6267:2;6260:5;6253:17;6307:7;6302:2;6297;6293;6289:11;6285:20;6282:33;6279:53;;;6328:1;6325;6318:12;6279:53;6383:2;6378;6374;6370:11;6365:2;6358:5;6354:14;6341:45;6427:1;6422:2;6417;6410:5;6406:14;6402:23;6395:34;;6448:5;6438:15;;;;;5479:980;;;;;;;:::o;6464:615::-;6550:6;6558;6611:2;6599:9;6590:7;6586:23;6582:32;6579:52;;;6627:1;6624;6617:12;6579:52;6667:9;6654:23;6696:18;6737:2;6729:6;6726:14;6723:34;;;6753:1;6750;6743:12;6723:34;6791:6;6780:9;6776:22;6766:32;;6836:7;6829:4;6825:2;6821:13;6817:27;6807:55;;6858:1;6855;6848:12;6807:55;6898:2;6885:16;6924:2;6916:6;6913:14;6910:34;;;6940:1;6937;6930:12;6910:34;6993:7;6988:2;6978:6;6975:1;6971:14;6967:2;6963:23;6959:32;6956:45;6953:65;;;7014:1;7011;7004:12;6953:65;7045:2;7037:11;;;;;7067:6;;-1:-1:-1;6464:615:1;;-1:-1:-1;;;;6464:615:1:o;7084:260::-;7152:6;7160;7213:2;7201:9;7192:7;7188:23;7184:32;7181:52;;;7229:1;7226;7219:12;7181:52;7252:29;7271:9;7252:29;:::i;:::-;7242:39;;7300:38;7334:2;7323:9;7319:18;7300:38;:::i;7349:380::-;7428:1;7424:12;;;;7471;;;7492:61;;7546:4;7538:6;7534:17;7524:27;;7492:61;7599:2;7591:6;7588:14;7568:18;7565:38;7562:161;;;7645:10;7640:3;7636:20;7633:1;7626:31;7680:4;7677:1;7670:15;7708:4;7705:1;7698:15;7562:161;;7349:380;;;:::o;8974:413::-;9176:2;9158:21;;;9215:2;9195:18;;;9188:30;9254:34;9249:2;9234:18;;9227:62;-1:-1:-1;;;9320:2:1;9305:18;;9298:47;9377:3;9362:19;;8974:413::o;10778:127::-;10839:10;10834:3;10830:20;10827:1;10820:31;10870:4;10867:1;10860:15;10894:4;10891:1;10884:15;10910:127;10971:10;10966:3;10962:20;10959:1;10952:31;11002:4;10999:1;10992:15;11026:4;11023:1;11016:15;11042:125;11082:4;11110:1;11107;11104:8;11101:34;;;11115:18;;:::i;:::-;-1:-1:-1;11152:9:1;;11042:125::o;13118:135::-;13157:3;-1:-1:-1;;13178:17:1;;13175:43;;;13198:18;;:::i;:::-;-1:-1:-1;13245:1:1;13234:13;;13118:135::o;13616:349::-;13818:2;13800:21;;;13857:2;13837:18;;;13830:30;13896:27;13891:2;13876:18;;13869:55;13956:2;13941:18;;13616:349::o;15126:136::-;15165:3;15193:5;15183:39;;15202:18;;:::i;:::-;-1:-1:-1;;;15238:18:1;;15126:136::o;15267:128::-;15307:3;15338:1;15334:6;15331:1;15328:13;15325:39;;;15344:18;;:::i;:::-;-1:-1:-1;15380:9:1;;15267:128::o;15400:168::-;15440:7;15506:1;15502;15498:6;15494:14;15491:1;15488:21;15483:1;15476:9;15469:17;15465:45;15462:71;;;15513:18;;:::i;:::-;-1:-1:-1;15553:9:1;;15400:168::o;16106:973::-;16191:12;;16156:3;;16246:1;16266:18;;;;16319;;;;16346:61;;16400:4;16392:6;16388:17;16378:27;;16346:61;16426:2;16474;16466:6;16463:14;16443:18;16440:38;16437:161;;;16520:10;16515:3;16511:20;16508:1;16501:31;16555:4;16552:1;16545:15;16583:4;16580:1;16573:15;16437:161;16614:18;16641:104;;;;16759:1;16754:319;;;;16607:466;;16641:104;-1:-1:-1;;16674:24:1;;16662:37;;16719:16;;;;-1:-1:-1;16641:104:1;;16754:319;16053:1;16046:14;;;16090:4;16077:18;;16848:1;16862:165;16876:6;16873:1;16870:13;16862:165;;;16954:14;;16941:11;;;16934:35;16997:16;;;;16891:10;;16862:165;;;16866:3;;17056:6;17051:3;17047:16;17040:23;;16607:466;;;;;;;16106:973;;;;:::o;17084:456::-;17305:3;17333:38;17367:3;17359:6;17333:38;:::i;:::-;17400:6;17394:13;17416:52;17461:6;17457:2;17450:4;17442:6;17438:17;17416:52;:::i;:::-;17484:50;17526:6;17522:2;17518:15;17510:6;17484:50;:::i;:::-;17477:57;17084:456;-1:-1:-1;;;;;;;17084:456:1:o;20668:414::-;20870:2;20852:21;;;20909:2;20889:18;;;20882:30;20948:34;20943:2;20928:18;;20921:62;-1:-1:-1;;;21014:2:1;20999:18;;20992:48;21072:3;21057:19;;20668:414::o;21087:127::-;21148:10;21143:3;21139:20;21136:1;21129:31;21179:4;21176:1;21169:15;21203:4;21200:1;21193:15;21219:120;21259:1;21285;21275:35;;21290:18;;:::i;:::-;-1:-1:-1;21324:9:1;;21219:120::o;21344:112::-;21376:1;21402;21392:35;;21407:18;;:::i;:::-;-1:-1:-1;21441:9:1;;21344:112::o;21461:786::-;21872:25;21867:3;21860:38;21842:3;21927:6;21921:13;21943:62;21998:6;21993:2;21988:3;21984:12;21977:4;21969:6;21965:17;21943:62;:::i;:::-;-1:-1:-1;;;22064:2:1;22024:16;;;22056:11;;;22049:40;22114:13;;22136:63;22114:13;22185:2;22177:11;;22170:4;22158:17;;22136:63;:::i;:::-;22219:17;22238:2;22215:26;;21461:786;-1:-1:-1;;;;21461:786:1:o;22252:127::-;22313:10;22308:3;22304:20;22301:1;22294:31;22344:4;22341:1;22334:15;22368:4;22365:1;22358:15;22384:489;-1:-1:-1;;;;;22653:15:1;;;22635:34;;22705:15;;22700:2;22685:18;;22678:43;22752:2;22737:18;;22730:34;;;22800:3;22795:2;22780:18;;22773:31;;;22578:4;;22821:46;;22847:19;;22839:6;22821:46;:::i;:::-;22813:54;22384:489;-1:-1:-1;;;;;;22384:489:1:o;22878:249::-;22947:6;23000:2;22988:9;22979:7;22975:23;22971:32;22968:52;;;23016:1;23013;23006:12;22968:52;23048:9;23042:16;23067:30;23091:5;23067:30;:::i

Swarm Source

ipfs://0c48bb9e343ee83b115fab6ee3e446e9c8eae067fa4dd5c98713f707d39f12a0

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