Token

Circle of Zav (CoZ)

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

ERC-721

NFT

Overview

Max Total Supply

1,003 CoZ

Holders

312

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xb5a1cde2a05fc64c95e04763fc8fca33aa5c2f8b

Filtered by Token Holder

0xAe7cD197F941FD1Bd39131152ef597aD49B43F2C

deg3ntrader.eth

Balance

1 CoZ

0xae7cd197f941fd1bd39131152ef597ad49b43f2c

OVERVIEW

The mission of CoZ is to become a leading creative community fueled with supporting creators & members into their own mythical worlds of limitless creativity.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

CircleOfZav

Compiler Version

v0.8.7+commit.e28d00a7

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-12-01
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;



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





/**
 * @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() {
        _setOwner(_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 {
        _setOwner(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");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}



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





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



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





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



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





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











/**
 * @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 {
        require(operator != _msgSender(), "ERC721: approve to caller");

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //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 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 {}
}



// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}



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



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

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

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

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

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

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

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

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

        return (signer, RecoverError.NoError);
    }

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

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

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



/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        bytes32 computedHash = leaf;

        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];

            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }

        // Check if the computed hash (root) is equal to the provided root
        return computedHash == root;
    }
}

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

abstract contract OperatorFilterer {
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);

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

    modifier onlyAllowedOperator(address from) virtual {
        // Allow spending tokens from addresses with balance
        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
        // from an EOA.
        if (from != msg.sender) {
            _checkFilterOperator(msg.sender);
        }
        _;
    }

    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    function _checkFilterOperator(address operator) internal view virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}

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

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

contract CircleOfZav is ERC721, DefaultOperatorFilterer, Ownable {
    using ECDSA for bytes32;
    using SafeMath for uint256;
    using Address for address;
    using Counters for Counters.Counter;

    Counters.Counter private Circles;
    string private baseURI;

    uint256 constant public maxCircles = 1001;
    uint256 public circlesMinted = 0;
    uint256 public circlesReserved = 0;

    uint256 public maxReserved = 50;
    uint256 public saleState = 0;
    uint256 public mintPrice = 0.05 ether;
    uint256 public maxPerTxn = 2;
    address public merkleAddress;

    // tracks the amount of tokens minted based on address during whitelist stage
    mapping(address => uint256) public whitelistMinted;
    mapping(address => uint256) public publicMinted;

    modifier contractBlocker() {
        require(tx.origin == msg.sender, "No Smart Contracts Allowed");
        _;
    }

    constructor() ERC721("Circle of Zav", "CoZ") {
        Circles.increment();
    }

    // reserves the circles for mr artist
    function reserve(uint256 amount) public payable onlyOwner {
        uint256 currentCircles = Circles.current();

        require(circlesReserved <= maxReserved, "You already reserved the max amount");

        for (uint256 i; i < amount; i++) {
            _safeMint(msg.sender, currentCircles + i);
            Circles.increment();
        }

        circlesReserved += amount;
    }

    // whitelist mint is stage 1
    function whitelistMint(uint256 amount, bytes calldata proof) public payable contractBlocker {
        uint256 currentCircles = Circles.current();

        require(saleState == 1, "Whitelist Mint is not ready");
        require(currentCircles <= maxCircles, "Max Supply reached");
        require(mintPrice * amount == msg.value, "Invalid Mint Price provided");
        require(amount >= 1 && amount <= maxPerTxn, "Invalid Quantity");
        require(whitelistMinted[msg.sender] < 3, "You already max minted for whitelist mint");
        require(isValidSignature(keccak256(abi.encodePacked(msg.sender, amount)), proof), "Invalid Proof Signature");

        whitelistMinted[msg.sender] += amount;

        for (uint256 i; i < amount; i++) {
            _safeMint(msg.sender, currentCircles + i);
            Circles.increment();
        }
    }

    // public mint is stage 2
    function publicMint(uint256 amount) public payable contractBlocker {
        uint256 currentCircles = Circles.current();

        require(saleState == 2, "Public Mint is not ready");
        require(currentCircles <= maxCircles, "Max Supply reached");
        require(mintPrice * amount == msg.value, "Invalid Mint Price provided");
        require(amount >= 1 && amount <= maxPerTxn, "Invalid Quantity");
        require(publicMinted[msg.sender] < 3, "You already max minted for the public mint");

        for (uint256 i; i < amount; i++) {
            _safeMint(msg.sender, currentCircles + i);
            Circles.increment();
        }
    }

    // updates the mint price
    function setMintPrice(uint256 _mintPrice) public payable onlyOwner {
        mintPrice = _mintPrice;
    }

    // sets the max mints per transaction
    function setMaxPer(uint256 _maxPerTxn) public payable onlyOwner {
        maxPerTxn = _maxPerTxn;
    }

    // returns the total amount minted
    function totalSupply() external view returns(uint256) {
        return Circles.current();
    }

    // required for the metadata to be visible on OS
    function _baseURI() internal view override returns (string memory) {
        return baseURI;
    }

    // updates the metadata base uri to the new one, used for revealing
    function setMetadata(string memory _baseUrl) public payable onlyOwner {
        baseURI = _baseUrl;
    }

    // withdraws the mint functions to the contract deployer
    function withdraw() public onlyOwner {
        uint256 balance = address(this).balance;
        payable(msg.sender).transfer(balance);
    }

    // validates the markle signature for whitelist
    function isValidSignature(bytes32 hash, bytes calldata sig) internal view returns (bool) {
        bytes32 signed = hash.toEthSignedMessageHash();
        
        return merkleAddress == signed.recover(sig);
    }

    // sets the proof sig address
    function setMerkleAddress(address _markleAddress) public onlyOwner {
        merkleAddress = _markleAddress;
    }

    // sets the sale state
    function setSaleState(uint256 _saleState) public onlyOwner {
        saleState = _saleState;
    }

    // sets the maxReserved incase it needs to be switched
    function setMaxReserved(uint256 _maxReserved) public onlyOwner {
        maxReserved = _maxReserved;
    }

    // helper functions required in order to transfer tokens
    function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
        super.setApprovalForAll(operator, approved);
    }

    function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
        super.approve(operator, tokenId);
    }

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

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

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

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"circlesMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"circlesReserved","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxCircles","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPerTxn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxReserved","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"publicMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"publicMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"reserve","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleState","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"_maxPerTxn","type":"uint256"}],"name":"setMaxPer","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxReserved","type":"uint256"}],"name":"setMaxReserved","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_markleAddress","type":"address"}],"name":"setMerkleAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseUrl","type":"string"}],"name":"setMetadata","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintPrice","type":"uint256"}],"name":"setMintPrice","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_saleState","type":"uint256"}],"name":"setSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"proof","type":"bytes"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelistMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

0x6080604052600436106102255760003560e01c8063715018a611610123578063a22cb465116100ab578063dc4bb0551161006f578063dc4bb055146105fa578063e346c12014610610578063e985e9c514610630578063f2fde38b14610679578063f4a0a5281461069957600080fd5b8063a22cb46514610571578063a49a1e7d14610591578063a9898fd9146105a4578063b88d4fde146105ba578063c87b56dd146105da57600080fd5b80638ad42bb7116100f25780638ad42bb7146104e85780638da5cb5b146104fe57806395d89b411461051c57806398a8cffe146105315780639e852f751461055e57600080fd5b8063715018a61461048a578063819b25ba1461049f57806384a822e6146104b257806389dddc59146104d257600080fd5b80633cb51994116101b1578063603f4d5211610175578063603f4d52146103fe5780636352211e146104145780636817c76c146104345780636bee18bd1461044a57806370a082311461046a57600080fd5b80633cb519941461037e5780633ccfd60b1461039457806341f43434146103a957806342842e0e146103cb57806352f1910d146103eb57600080fd5b8063095ea7b3116101f8578063095ea7b3146102db5780631015805b146102fb57806318160ddd1461033657806323b872dd1461034b5780632db115441461036b57600080fd5b806301ffc9a71461022a57806306fdde031461025f578063081812fc14610281578063084c4088146102b9575b600080fd5b34801561023657600080fd5b5061024a6102453660046124a5565b6106ac565b60405190151581526020015b60405180910390f35b34801561026b57600080fd5b506102746106fe565b6040516102569190612655565b34801561028d57600080fd5b506102a161029c366004612528565b610790565b6040516001600160a01b039091168152602001610256565b3480156102c557600080fd5b506102d96102d4366004612528565b61082a565b005b3480156102e757600080fd5b506102d96102f636600461245e565b610859565b34801561030757600080fd5b50610328610316366004612321565b60116020526000908152604090205481565b604051908152602001610256565b34801561034257600080fd5b50610328610872565b34801561035757600080fd5b506102d961036636600461236f565b610882565b6102d9610379366004612528565b6108ad565b34801561038a57600080fd5b50610328600e5481565b3480156103a057600080fd5b506102d9610b00565b3480156103b557600080fd5b506102a16daaeb6d7670e522a718067333cd4e81565b3480156103d757600080fd5b506102d96103e636600461236f565b610b5d565b6102d96103f9366004612528565b610b92565b34801561040a57600080fd5b50610328600c5481565b34801561042057600080fd5b506102a161042f366004612528565b610bc1565b34801561044057600080fd5b50610328600d5481565b34801561045657600080fd5b506102d9610465366004612528565b610c38565b34801561047657600080fd5b50610328610485366004612321565b610c67565b34801561049657600080fd5b506102d9610cee565b6102d96104ad366004612528565b610d24565b3480156104be57600080fd5b506102d96104cd366004612321565b610e10565b3480156104de57600080fd5b5061032860095481565b3480156104f457600080fd5b50610328600a5481565b34801561050a57600080fd5b506006546001600160a01b03166102a1565b34801561052857600080fd5b50610274610e5c565b34801561053d57600080fd5b5061032861054c366004612321565b60106020526000908152604090205481565b6102d961056c366004612541565b610e6b565b34801561057d57600080fd5b506102d961058c366004612427565b611176565b6102d961059f3660046124df565b61118a565b3480156105b057600080fd5b50610328600b5481565b3480156105c657600080fd5b506102d96105d53660046123ab565b6111c7565b3480156105e657600080fd5b506102746105f5366004612528565b6111ed565b34801561060657600080fd5b506103286103e981565b34801561061c57600080fd5b50600f546102a1906001600160a01b031681565b34801561063c57600080fd5b5061024a61064b36600461233c565b6001600160a01b03918216600090815260056020908152604080832093909416825291909152205460ff1690565b34801561068557600080fd5b506102d9610694366004612321565b6112c8565b6102d96106a7366004612528565b611363565b60006001600160e01b031982166380ac58cd60e01b14806106dd57506001600160e01b03198216635b5e139f60e01b145b806106f857506301ffc9a760e01b6001600160e01b03198316145b92915050565b60606000805461070d906127ce565b80601f0160208091040260200160405190810160405280929190818152602001828054610739906127ce565b80156107865780601f1061075b57610100808354040283529160200191610786565b820191906000526020600020905b81548152906001019060200180831161076957829003601f168201915b5050505050905090565b6000818152600260205260408120546001600160a01b031661080e5760405162461bcd60e51b815260206004820152602c60248201527f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860448201526b34b9ba32b73a103a37b5b2b760a11b60648201526084015b60405180910390fd5b506000908152600460205260409020546001600160a01b031690565b6006546001600160a01b031633146108545760405162461bcd60e51b8152600401610805906126ba565b600c55565b816108638161139b565b61086d8383611463565b505050565b600061087d60075490565b905090565b826001600160a01b038116331461089c5761089c3361139b565b6108a7848484611574565b50505050565b3233146108fc5760405162461bcd60e51b815260206004820152601a60248201527f4e6f20536d61727420436f6e74726163747320416c6c6f7765640000000000006044820152606401610805565b600061090760075490565b9050600c5460021461095b5760405162461bcd60e51b815260206004820152601860248201527f5075626c6963204d696e74206973206e6f7420726561647900000000000000006044820152606401610805565b6103e98111156109a25760405162461bcd60e51b815260206004820152601260248201527113585e0814dd5c1c1b1e481c995858da195960721b6044820152606401610805565b3482600d546109b1919061276c565b146109fe5760405162461bcd60e51b815260206004820152601b60248201527f496e76616c6964204d696e742050726963652070726f766964656400000000006044820152606401610805565b60018210158015610a115750600e548211155b610a505760405162461bcd60e51b815260206004820152601060248201526f496e76616c6964205175616e7469747960801b6044820152606401610805565b33600090815260116020526040902054600311610ac25760405162461bcd60e51b815260206004820152602a60248201527f596f7520616c7265616479206d6178206d696e74656420666f722074686520706044820152691d589b1a58c81b5a5b9d60b21b6064820152608401610805565b60005b8281101561086d57610ae033610adb8385612740565b6115a5565b610aee600780546001019055565b80610af881612809565b915050610ac5565b6006546001600160a01b03163314610b2a5760405162461bcd60e51b8152600401610805906126ba565b6040514790339082156108fc029083906000818181858888f19350505050158015610b59573d6000803e3d6000fd5b5050565b826001600160a01b0381163314610b7757610b773361139b565b6108a7848484604051806020016040528060008152506111c7565b6006546001600160a01b03163314610bbc5760405162461bcd60e51b8152600401610805906126ba565b600e55565b6000818152600260205260408120546001600160a01b0316806106f85760405162461bcd60e51b815260206004820152602960248201527f4552433732313a206f776e657220717565727920666f72206e6f6e657869737460448201526832b73a103a37b5b2b760b91b6064820152608401610805565b6006546001600160a01b03163314610c625760405162461bcd60e51b8152600401610805906126ba565b600b55565b60006001600160a01b038216610cd25760405162461bcd60e51b815260206004820152602a60248201527f4552433732313a2062616c616e636520717565727920666f7220746865207a65604482015269726f206164647265737360b01b6064820152608401610805565b506001600160a01b031660009081526003602052604090205490565b6006546001600160a01b03163314610d185760405162461bcd60e51b8152600401610805906126ba565b610d2260006115bf565b565b6006546001600160a01b03163314610d4e5760405162461bcd60e51b8152600401610805906126ba565b6000610d5960075490565b9050600b54600a541115610dbb5760405162461bcd60e51b815260206004820152602360248201527f596f7520616c726561647920726573657276656420746865206d617820616d6f6044820152621d5b9d60ea1b6064820152608401610805565b60005b82811015610df457610dd433610adb8385612740565b610de2600780546001019055565b80610dec81612809565b915050610dbe565b5081600a6000828254610e079190612740565b90915550505050565b6006546001600160a01b03163314610e3a5760405162461bcd60e51b8152600401610805906126ba565b600f80546001600160a01b0319166001600160a01b0392909216919091179055565b60606001805461070d906127ce565b323314610eba5760405162461bcd60e51b815260206004820152601a60248201527f4e6f20536d61727420436f6e74726163747320416c6c6f7765640000000000006044820152606401610805565b6000610ec560075490565b9050600c54600114610f195760405162461bcd60e51b815260206004820152601b60248201527f57686974656c697374204d696e74206973206e6f7420726561647900000000006044820152606401610805565b6103e9811115610f605760405162461bcd60e51b815260206004820152601260248201527113585e0814dd5c1c1b1e481c995858da195960721b6044820152606401610805565b3484600d54610f6f919061276c565b14610fbc5760405162461bcd60e51b815260206004820152601b60248201527f496e76616c6964204d696e742050726963652070726f766964656400000000006044820152606401610805565b60018410158015610fcf5750600e548411155b61100e5760405162461bcd60e51b815260206004820152601060248201526f496e76616c6964205175616e7469747960801b6044820152606401610805565b3360009081526010602052604090205460031161107f5760405162461bcd60e51b815260206004820152602960248201527f596f7520616c7265616479206d6178206d696e74656420666f722077686974656044820152681b1a5cdd081b5a5b9d60ba1b6064820152608401610805565b6040516bffffffffffffffffffffffff193360601b166020820152603481018590526110c590605401604051602081830303815290604052805190602001208484611611565b6111115760405162461bcd60e51b815260206004820152601760248201527f496e76616c69642050726f6f66205369676e61747572650000000000000000006044820152606401610805565b3360009081526010602052604081208054869290611130908490612740565b90915550600090505b8481101561116f5761114f33610adb8385612740565b61115d600780546001019055565b8061116781612809565b915050611139565b5050505050565b816111808161139b565b61086d83836116c9565b6006546001600160a01b031633146111b45760405162461bcd60e51b8152600401610805906126ba565b8051610b599060089060208401906121f6565b836001600160a01b03811633146111e1576111e13361139b565b61116f8585858561178e565b6000818152600260205260409020546060906001600160a01b031661126c5760405162461bcd60e51b815260206004820152602f60248201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60448201526e3732bc34b9ba32b73a103a37b5b2b760891b6064820152608401610805565b60006112766117c0565b9050600081511161129657604051806020016040528060008152506112c1565b806112a0846117cf565b6040516020016112b19291906125e9565b6040516020818303038152906040525b9392505050565b6006546001600160a01b031633146112f25760405162461bcd60e51b8152600401610805906126ba565b6001600160a01b0381166113575760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610805565b611360816115bf565b50565b6006546001600160a01b0316331461138d5760405162461bcd60e51b8152600401610805906126ba565b600d55565b80546001019055565b6daaeb6d7670e522a718067333cd4e3b1561136057604051633185c44d60e21b81523060048201526001600160a01b03821660248201526daaeb6d7670e522a718067333cd4e9063c61711349060440160206040518083038186803b15801561140357600080fd5b505afa158015611417573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061143b9190612488565b61136057604051633b79c77360e21b81526001600160a01b0382166004820152602401610805565b600061146e82610bc1565b9050806001600160a01b0316836001600160a01b031614156114dc5760405162461bcd60e51b815260206004820152602160248201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e656044820152603960f91b6064820152608401610805565b336001600160a01b03821614806114f857506114f8813361064b565b61156a5760405162461bcd60e51b815260206004820152603860248201527f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760448201527f6e6572206e6f7220617070726f76656420666f7220616c6c00000000000000006064820152608401610805565b61086d83836118d5565b61157e3382611943565b61159a5760405162461bcd60e51b8152600401610805906126ef565b61086d838383611a36565b610b59828260405180602001604052806000815250611bd6565b600680546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b60008061166b856040517f19457468657265756d205369676e6564204d6573736167653a0a3332000000006020820152603c8101829052600090605c01604051602081830303815290604052805190602001209050919050565b90506116af84848080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152508593925050611c099050565b600f546001600160a01b0391821691161495945050505050565b6001600160a01b0382163314156117225760405162461bcd60e51b815260206004820152601960248201527f4552433732313a20617070726f766520746f2063616c6c6572000000000000006044820152606401610805565b3360008181526005602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b6117983383611943565b6117b45760405162461bcd60e51b8152600401610805906126ef565b6108a784848484611c2d565b60606008805461070d906127ce565b6060816117f35750506040805180820190915260018152600360fc1b602082015290565b8160005b811561181d578061180781612809565b91506118169050600a83612758565b91506117f7565b60008167ffffffffffffffff81111561183857611838612890565b6040519080825280601f01601f191660200182016040528015611862576020820181803683370190505b5090505b84156118cd5761187760018361278b565b9150611884600a86612824565b61188f906030612740565b60f81b8183815181106118a4576118a461287a565b60200101906001600160f81b031916908160001a9053506118c6600a86612758565b9450611866565b949350505050565b600081815260046020526040902080546001600160a01b0319166001600160a01b038416908117909155819061190a82610bc1565b6001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b6000818152600260205260408120546001600160a01b03166119bc5760405162461bcd60e51b815260206004820152602c60248201527f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860448201526b34b9ba32b73a103a37b5b2b760a11b6064820152608401610805565b60006119c783610bc1565b9050806001600160a01b0316846001600160a01b03161480611a025750836001600160a01b03166119f784610790565b6001600160a01b0316145b806118cd57506001600160a01b0380821660009081526005602090815260408083209388168352929052205460ff166118cd565b826001600160a01b0316611a4982610bc1565b6001600160a01b031614611ab15760405162461bcd60e51b815260206004820152602960248201527f4552433732313a207472616e73666572206f6620746f6b656e2074686174206960448201526839903737ba1037bbb760b91b6064820152608401610805565b6001600160a01b038216611b135760405162461bcd60e51b8152602060048201526024808201527f4552433732313a207472616e7366657220746f20746865207a65726f206164646044820152637265737360e01b6064820152608401610805565b611b1e6000826118d5565b6001600160a01b0383166000908152600360205260408120805460019290611b4790849061278b565b90915550506001600160a01b0382166000908152600360205260408120805460019290611b75908490612740565b909155505060008181526002602052604080822080546001600160a01b0319166001600160a01b0386811691821790925591518493918716917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a4505050565b611be08383611c60565b611bed6000848484611da2565b61086d5760405162461bcd60e51b815260040161080590612668565b6000806000611c188585611eaf565b91509150611c2581611f1f565b509392505050565b611c38848484611a36565b611c4484848484611da2565b6108a75760405162461bcd60e51b815260040161080590612668565b6001600160a01b038216611cb65760405162461bcd60e51b815260206004820181905260248201527f4552433732313a206d696e7420746f20746865207a65726f20616464726573736044820152606401610805565b6000818152600260205260409020546001600160a01b031615611d1b5760405162461bcd60e51b815260206004820152601c60248201527f4552433732313a20746f6b656e20616c7265616479206d696e746564000000006044820152606401610805565b6001600160a01b0382166000908152600360205260408120805460019290611d44908490612740565b909155505060008181526002602052604080822080546001600160a01b0319166001600160a01b03861690811790915590518392907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a45050565b60006001600160a01b0384163b15611ea457604051630a85bd0160e11b81526001600160a01b0385169063150b7a0290611de6903390899088908890600401612618565b602060405180830381600087803b158015611e0057600080fd5b505af1925050508015611e30575060408051601f3d908101601f19168201909252611e2d918101906124c2565b60015b611e8a573d808015611e5e576040519150601f19603f3d011682016040523d82523d6000602084013e611e63565b606091505b508051611e825760405162461bcd60e51b815260040161080590612668565b805181602001fd5b6001600160e01b031916630a85bd0160e11b1490506118cd565b506001949350505050565b600080825160411415611ee65760208301516040840151606085015160001a611eda878285856120da565b94509450505050611f18565b825160401415611f105760208301516040840151611f058683836121c7565b935093505050611f18565b506000905060025b9250929050565b6000816004811115611f3357611f33612864565b1415611f3c5750565b6001816004811115611f5057611f50612864565b1415611f9e5760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e617475726500000000000000006044820152606401610805565b6002816004811115611fb257611fb2612864565b14156120005760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e677468006044820152606401610805565b600381600481111561201457612014612864565b141561206d5760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604482015261756560f01b6064820152608401610805565b600481600481111561208157612081612864565b14156113605760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202776272076616c604482015261756560f01b6064820152608401610805565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a083111561211157506000905060036121be565b8460ff16601b1415801561212957508460ff16601c14155b1561213a57506000905060046121be565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa15801561218e573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b0381166121b7576000600192509250506121be565b9150600090505b94509492505050565b6000806001600160ff1b03831660ff84901c601b016121e8878288856120da565b935093505050935093915050565b828054612202906127ce565b90600052602060002090601f016020900481019282612224576000855561226a565b82601f1061223d57805160ff191683800117855561226a565b8280016001018555821561226a579182015b8281111561226a57825182559160200191906001019061224f565b5061227692915061227a565b5090565b5b80821115612276576000815560010161227b565b600067ffffffffffffffff808411156122aa576122aa612890565b604051601f8501601f19908116603f011681019082821181831017156122d2576122d2612890565b816040528093508581528686860111156122eb57600080fd5b858560208301376000602087830101525050509392505050565b80356001600160a01b038116811461231c57600080fd5b919050565b60006020828403121561233357600080fd5b6112c182612305565b6000806040838503121561234f57600080fd5b61235883612305565b915061236660208401612305565b90509250929050565b60008060006060848603121561238457600080fd5b61238d84612305565b925061239b60208501612305565b9150604084013590509250925092565b600080600080608085870312156123c157600080fd5b6123ca85612305565b93506123d860208601612305565b925060408501359150606085013567ffffffffffffffff8111156123fb57600080fd5b8501601f8101871361240c57600080fd5b61241b8782356020840161228f565b91505092959194509250565b6000806040838503121561243a57600080fd5b61244383612305565b91506020830135612453816128a6565b809150509250929050565b6000806040838503121561247157600080fd5b61247a83612305565b946020939093013593505050565b60006020828403121561249a57600080fd5b81516112c1816128a6565b6000602082840312156124b757600080fd5b81356112c1816128b4565b6000602082840312156124d457600080fd5b81516112c1816128b4565b6000602082840312156124f157600080fd5b813567ffffffffffffffff81111561250857600080fd5b8201601f8101841361251957600080fd5b6118cd8482356020840161228f565b60006020828403121561253a57600080fd5b5035919050565b60008060006040848603121561255657600080fd5b83359250602084013567ffffffffffffffff8082111561257557600080fd5b818601915086601f83011261258957600080fd5b81358181111561259857600080fd5b8760208285010111156125aa57600080fd5b6020830194508093505050509250925092565b600081518084526125d58160208601602086016127a2565b601f01601f19169290920160200192915050565b600083516125fb8184602088016127a2565b83519083019061260f8183602088016127a2565b01949350505050565b6001600160a01b038581168252841660208201526040810183905260806060820181905260009061264b908301846125bd565b9695505050505050565b6020815260006112c160208301846125bd565b60208082526032908201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560408201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b606082015260800190565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b60208082526031908201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f6040820152701ddb995c881b9bdc88185c1c1c9bdd9959607a1b606082015260800190565b6000821982111561275357612753612838565b500190565b6000826127675761276761284e565b500490565b600081600019048311821515161561278657612786612838565b500290565b60008282101561279d5761279d612838565b500390565b60005b838110156127bd5781810151838201526020016127a5565b838111156108a75750506000910152565b600181811c908216806127e257607f821691505b6020821081141561280357634e487b7160e01b600052602260045260246000fd5b50919050565b600060001982141561281d5761281d612838565b5060010190565b6000826128335761283361284e565b500690565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052601260045260246000fd5b634e487b7160e01b600052602160045260246000fd5b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052604160045260246000fd5b801515811461136057600080fd5b6001600160e01b03198116811461136057600080fdfea26469706673582212208fc7a61292f0693797343da98922f86c7094971d039a8d8afe72863cfdb8584d64736f6c63430008070033

Deployed Bytecode Sourcemap

57363:5778:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22101:305;;;;;;;;;;-1:-1:-1;22101:305:0;;;;;:::i;:::-;;:::i;:::-;;;7521:14:1;;7514:22;7496:41;;7484:2;7469:18;22101:305:0;;;;;;;;23046:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;24605:221::-;;;;;;;;;;-1:-1:-1;24605:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;6510:32:1;;;6492:51;;6480:2;6465:18;24605:221:0;6346:203:1;61899:100:0;;;;;;;;;;-1:-1:-1;61899:100:0;;;;;:::i;:::-;;:::i;:::-;;62429:157;;;;;;;;;;-1:-1:-1;62429:157:0;;;;;:::i;:::-;;:::i;58103:47::-;;;;;;;;;;-1:-1:-1;58103:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;20151:25:1;;;20139:2;20124:18;58103:47:0;20005:177:1;60765:97:0;;;;;;;;;;;;;:::i;62594:163::-;;;;;;;;;;-1:-1:-1;62594:163:0;;;;;:::i;:::-;;:::i;59755:659::-;;;;;;:::i;:::-;;:::i;57891:28::-;;;;;;;;;;;;;;;;61282:143;;;;;;;;;;;;;:::i;55121:::-;;;;;;;;;;;;55221:42;55121:143;;62765:169;;;;;;;;;;-1:-1:-1;62765:169:0;;;;;:::i;:::-;;:::i;60612:105::-;;;;;;:::i;:::-;;:::i;57812:28::-;;;;;;;;;;;;;;;;22740:239;;;;;;;;;;-1:-1:-1;22740:239:0;;;;;:::i;:::-;;:::i;57847:37::-;;;;;;;;;;;;;;;;62067:108;;;;;;;;;;-1:-1:-1;62067:108:0;;;;;:::i;:::-;;:::i;22470:208::-;;;;;;;;;;-1:-1:-1;22470:208:0;;;;;:::i;:::-;;:::i;2387:94::-;;;;;;;;;;;;;:::i;58421:395::-;;;;;;:::i;:::-;;:::i;61747:116::-;;;;;;;;;;-1:-1:-1;61747:116:0;;;;;:::i;:::-;;:::i;57692:32::-;;;;;;;;;;;;;;;;57731:34;;;;;;;;;;;;;;;;1736:87;;;;;;;;;;-1:-1:-1;1809:6:0;;-1:-1:-1;;;;;1809:6:0;1736:87;;23215:104;;;;;;;;;;;;;:::i;58046:50::-;;;;;;;;;;-1:-1:-1;58046:50:0;;;;;:::i;:::-;;;;;;;;;;;;;;58858:858;;;;;;:::i;:::-;;:::i;62245:176::-;;;;;;;;;;-1:-1:-1;62245:176:0;;;;;:::i;:::-;;:::i;61105:107::-;;;;;;:::i;:::-;;:::i;57774:31::-;;;;;;;;;;;;;;;;62942:196;;;;;;;;;;-1:-1:-1;62942:196:0;;;;;:::i;:::-;;:::i;23390:334::-;;;;;;;;;;-1:-1:-1;23390:334:0;;;;;:::i;:::-;;:::i;57644:41::-;;;;;;;;;;;;57681:4;57644:41;;57926:28;;;;;;;;;;-1:-1:-1;57926:28:0;;;;-1:-1:-1;;;;;57926:28:0;;;25264:164;;;;;;;;;;-1:-1:-1;25264:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;25385:25:0;;;25361:4;25385:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;25264:164;2636:192;;;;;;;;;;-1:-1:-1;2636:192:0;;;;;:::i;:::-;;:::i;60453:108::-;;;;;;:::i;:::-;;:::i;22101:305::-;22203:4;-1:-1:-1;;;;;;22240:40:0;;-1:-1:-1;;;22240:40:0;;:105;;-1:-1:-1;;;;;;;22297:48:0;;-1:-1:-1;;;22297:48:0;22240:105;:158;;;-1:-1:-1;;;;;;;;;;20799:40:0;;;22362:36;22220:178;22101:305;-1:-1:-1;;22101:305:0:o;23046:100::-;23100:13;23133:5;23126:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23046:100;:::o;24605:221::-;24681:7;28088:16;;;:7;:16;;;;;;-1:-1:-1;;;;;28088:16:0;24701:73;;;;-1:-1:-1;;;24701:73:0;;17023:2:1;24701:73:0;;;17005:21:1;17062:2;17042:18;;;17035:30;17101:34;17081:18;;;17074:62;-1:-1:-1;;;17152:18:1;;;17145:42;17204:19;;24701:73:0;;;;;;;;;-1:-1:-1;24794:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;24794:24:0;;24605:221::o;61899:100::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;61969:9:::1;:22:::0;61899:100::o;62429:157::-;62525:8;56642:30;56663:8;56642:20;:30::i;:::-;62546:32:::1;62560:8;62570:7;62546:13;:32::i;:::-;62429:157:::0;;;:::o;60765:97::-;60810:7;60837:17;:7;41921:14;;41829:114;60837:17;60830:24;;60765:97;:::o;62594:163::-;62695:4;-1:-1:-1;;;;;56462:18:0;;56470:10;56462:18;56458:83;;56497:32;56518:10;56497:20;:32::i;:::-;62712:37:::1;62731:4;62737:2;62741:7;62712:18;:37::i;:::-;62594:163:::0;;;;:::o;59755:659::-;58205:9;58218:10;58205:23;58197:62;;;;-1:-1:-1;;;58197:62:0;;8970:2:1;58197:62:0;;;8952:21:1;9009:2;8989:18;;;8982:30;9048:28;9028:18;;;9021:56;9094:18;;58197:62:0;8768:350:1;58197:62:0;59833:22:::1;59858:17;:7;41921:14:::0;;41829:114;59858:17:::1;59833:42;;59896:9;;59909:1;59896:14;59888:51;;;::::0;-1:-1:-1;;;59888:51:0;;19025:2:1;59888:51:0::1;::::0;::::1;19007:21:1::0;19064:2;19044:18;;;19037:30;19103:26;19083:18;;;19076:54;19147:18;;59888:51:0::1;18823:348:1::0;59888:51:0::1;57681:4;59958:14;:28;;59950:59;;;::::0;-1:-1:-1;;;59950:59:0;;16676:2:1;59950:59:0::1;::::0;::::1;16658:21:1::0;16715:2;16695:18;;;16688:30;-1:-1:-1;;;16734:18:1;;;16727:48;16792:18;;59950:59:0::1;16474:342:1::0;59950:59:0::1;60050:9;60040:6;60028:9;;:18;;;;:::i;:::-;:31;60020:71;;;::::0;-1:-1:-1;;;60020:71:0;;11569:2:1;60020:71:0::1;::::0;::::1;11551:21:1::0;11608:2;11588:18;;;11581:30;11647:29;11627:18;;;11620:57;11694:18;;60020:71:0::1;11367:351:1::0;60020:71:0::1;60120:1;60110:6;:11;;:34;;;;;60135:9;;60125:6;:19;;60110:34;60102:63;;;::::0;-1:-1:-1;;;60102:63:0;;10041:2:1;60102:63:0::1;::::0;::::1;10023:21:1::0;10080:2;10060:18;;;10053:30;-1:-1:-1;;;10099:18:1;;;10092:46;10155:18;;60102:63:0::1;9839:340:1::0;60102:63:0::1;60197:10;60184:24;::::0;;;:12:::1;:24;::::0;;;;;60211:1:::1;-1:-1:-1::0;60176:83:0::1;;;::::0;-1:-1:-1;;;60176:83:0;;19796:2:1;60176:83:0::1;::::0;::::1;19778:21:1::0;19835:2;19815:18;;;19808:30;19874:34;19854:18;;;19847:62;-1:-1:-1;;;19925:18:1;;;19918:40;19975:19;;60176:83:0::1;19594:406:1::0;60176:83:0::1;60277:9;60272:135;60292:6;60288:1;:10;60272:135;;;60320:41;60330:10;60342:18;60359:1:::0;60342:14;:18:::1;:::i;:::-;60320:9;:41::i;:::-;60376:19;:7;42040:19:::0;;42058:1;42040:19;;;41951:127;60376:19:::1;60300:3:::0;::::1;::::0;::::1;:::i;:::-;;;;60272:135;;61282:143:::0;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;61380:37:::1;::::0;61348:21:::1;::::0;61388:10:::1;::::0;61380:37;::::1;;;::::0;61348:21;;61330:15:::1;61380:37:::0;61330:15;61380:37;61348:21;61388:10;61380:37;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;61319:106;61282:143::o:0;62765:169::-;62870:4;-1:-1:-1;;;;;56462:18:0;;56470:10;56462:18;56458:83;;56497:32;56518:10;56497:20;:32::i;:::-;62887:39:::1;62904:4;62910:2;62914:7;62887:39;;;;;;;;;;;::::0;:16:::1;:39::i;60612:105::-:0;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;60687:9:::1;:22:::0;60612:105::o;22740:239::-;22812:7;22848:16;;;:7;:16;;;;;;-1:-1:-1;;;;;22848:16:0;22883:19;22875:73;;;;-1:-1:-1;;;22875:73:0;;15150:2:1;22875:73:0;;;15132:21:1;15189:2;15169:18;;;15162:30;15228:34;15208:18;;;15201:62;-1:-1:-1;;;15279:18:1;;;15272:39;15328:19;;22875:73:0;14948:405:1;62067:108:0;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;62141:11:::1;:26:::0;62067:108::o;22470:208::-;22542:7;-1:-1:-1;;;;;22570:19:0;;22562:74;;;;-1:-1:-1;;;22562:74:0;;14739:2:1;22562:74:0;;;14721:21:1;14778:2;14758:18;;;14751:30;14817:34;14797:18;;;14790:62;-1:-1:-1;;;14868:18:1;;;14861:40;14918:19;;22562:74:0;14537:406:1;22562:74:0;-1:-1:-1;;;;;;22654:16:0;;;;;:9;:16;;;;;;;22470:208::o;2387:94::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;2452:21:::1;2470:1;2452:9;:21::i;:::-;2387:94::o:0;58421:395::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;58490:22:::1;58515:17;:7;41921:14:::0;;41829:114;58515:17:::1;58490:42;;58572:11;;58553:15;;:30;;58545:78;;;::::0;-1:-1:-1;;;58545:78:0;;13500:2:1;58545:78:0::1;::::0;::::1;13482:21:1::0;13539:2;13519:18;;;13512:30;13578:34;13558:18;;;13551:62;-1:-1:-1;;;13629:18:1;;;13622:33;13672:19;;58545:78:0::1;13298:399:1::0;58545:78:0::1;58641:9;58636:135;58656:6;58652:1;:10;58636:135;;;58684:41;58694:10;58706:18;58723:1:::0;58706:14;:18:::1;:::i;58684:41::-;58740:19;:7;42040:19:::0;;42058:1;42040:19;;;41951:127;58740:19:::1;58664:3:::0;::::1;::::0;::::1;:::i;:::-;;;;58636:135;;;;58802:6;58783:15;;:25;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;;;58421:395:0:o;61747:116::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;61825:13:::1;:30:::0;;-1:-1:-1;;;;;;61825:30:0::1;-1:-1:-1::0;;;;;61825:30:0;;;::::1;::::0;;;::::1;::::0;;61747:116::o;23215:104::-;23271:13;23304:7;23297:14;;;;;:::i;58858:858::-;58205:9;58218:10;58205:23;58197:62;;;;-1:-1:-1;;;58197:62:0;;8970:2:1;58197:62:0;;;8952:21:1;9009:2;8989:18;;;8982:30;9048:28;9028:18;;;9021:56;9094:18;;58197:62:0;8768:350:1;58197:62:0;58961:22:::1;58986:17;:7;41921:14:::0;;41829:114;58986:17:::1;58961:42;;59024:9;;59037:1;59024:14;59016:54;;;::::0;-1:-1:-1;;;59016:54:0;;9685:2:1;59016:54:0::1;::::0;::::1;9667:21:1::0;9724:2;9704:18;;;9697:30;9763:29;9743:18;;;9736:57;9810:18;;59016:54:0::1;9483:351:1::0;59016:54:0::1;57681:4;59089:14;:28;;59081:59;;;::::0;-1:-1:-1;;;59081:59:0;;16676:2:1;59081:59:0::1;::::0;::::1;16658:21:1::0;16715:2;16695:18;;;16688:30;-1:-1:-1;;;16734:18:1;;;16727:48;16792:18;;59081:59:0::1;16474:342:1::0;59081:59:0::1;59181:9;59171:6;59159:9;;:18;;;;:::i;:::-;:31;59151:71;;;::::0;-1:-1:-1;;;59151:71:0;;11569:2:1;59151:71:0::1;::::0;::::1;11551:21:1::0;11608:2;11588:18;;;11581:30;11647:29;11627:18;;;11620:57;11694:18;;59151:71:0::1;11367:351:1::0;59151:71:0::1;59251:1;59241:6;:11;;:34;;;;;59266:9;;59256:6;:19;;59241:34;59233:63;;;::::0;-1:-1:-1;;;59233:63:0;;10041:2:1;59233:63:0::1;::::0;::::1;10023:21:1::0;10080:2;10060:18;;;10053:30;-1:-1:-1;;;10099:18:1;;;10092:46;10155:18;;59233:63:0::1;9839:340:1::0;59233:63:0::1;59331:10;59315:27;::::0;;;:15:::1;:27;::::0;;;;;59345:1:::1;-1:-1:-1::0;59307:85:0::1;;;::::0;-1:-1:-1;;;59307:85:0;;14329:2:1;59307:85:0::1;::::0;::::1;14311:21:1::0;14368:2;14348:18;;;14341:30;14407:34;14387:18;;;14380:62;-1:-1:-1;;;14458:18:1;;;14451:39;14507:19;;59307:85:0::1;14127:405:1::0;59307:85:0::1;59438:36;::::0;-1:-1:-1;;59455:10:0::1;5364:2:1::0;5360:15;5356:53;59438:36:0::1;::::0;::::1;5344:66:1::0;5426:12;;;5419:28;;;59411:72:0::1;::::0;5463:12:1;;59438:36:0::1;;;;;;;;;;;;59428:47;;;;;;59477:5;;59411:16;:72::i;:::-;59403:108;;;::::0;-1:-1:-1;;;59403:108:0;;16324:2:1;59403:108:0::1;::::0;::::1;16306:21:1::0;16363:2;16343:18;;;16336:30;16402:25;16382:18;;;16375:53;16445:18;;59403:108:0::1;16122:347:1::0;59403:108:0::1;59540:10;59524:27;::::0;;;:15:::1;:27;::::0;;;;:37;;59555:6;;59524:27;:37:::1;::::0;59555:6;;59524:37:::1;:::i;:::-;::::0;;;-1:-1:-1;59579:9:0::1;::::0;-1:-1:-1;59574:135:0::1;59594:6;59590:1;:10;59574:135;;;59622:41;59632:10;59644:18;59661:1:::0;59644:14;:18:::1;:::i;59622:41::-;59678:19;:7;42040:19:::0;;42058:1;42040:19;;;41951:127;59678:19:::1;59602:3:::0;::::1;::::0;::::1;:::i;:::-;;;;59574:135;;;;58950:766;58858:858:::0;;;:::o;62245:176::-;62349:8;56642:30;56663:8;56642:20;:30::i;:::-;62370:43:::1;62394:8;62404;62370:23;:43::i;61105:107::-:0;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;61186:18;;::::1;::::0;:7:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;62942:196::-:0;63066:4;-1:-1:-1;;;;;56462:18:0;;56470:10;56462:18;56458:83;;56497:32;56518:10;56497:20;:32::i;:::-;63083:47:::1;63106:4;63112:2;63116:7;63125:4;63083:22;:47::i;23390:334::-:0;28064:4;28088:16;;;:7;:16;;;;;;23463:13;;-1:-1:-1;;;;;28088:16:0;23489:76;;;;-1:-1:-1;;;23489:76:0;;18207:2:1;23489:76:0;;;18189:21:1;18246:2;18226:18;;;18219:30;18285:34;18265:18;;;18258:62;-1:-1:-1;;;18336:18:1;;;18329:45;18391:19;;23489:76:0;18005:411:1;23489:76:0;23578:21;23602:10;:8;:10::i;:::-;23578:34;;23654:1;23636:7;23630:21;:25;:86;;;;;;;;;;;;;;;;;23682:7;23691:18;:7;:16;:18::i;:::-;23665:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;23630:86;23623:93;23390:334;-1:-1:-1;;;23390:334:0:o;2636:192::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;2725:22:0;::::1;2717:73;;;::::0;-1:-1:-1;;;2717:73:0;;10805:2:1;2717:73:0::1;::::0;::::1;10787:21:1::0;10844:2;10824:18;;;10817:30;10883:34;10863:18;;;10856:62;-1:-1:-1;;;10934:18:1;;;10927:36;10980:19;;2717:73:0::1;10603:402:1::0;2717:73:0::1;2801:19;2811:8;2801:9;:19::i;:::-;2636:192:::0;:::o;60453:108::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;60531:9:::1;:22:::0;60453:108::o;41951:127::-;42040:19;;42058:1;42040:19;;;41951:127::o;56700:419::-;55221:42;56891:45;:49;56887:225;;56962:67;;-1:-1:-1;;;56962:67:0;;57013:4;56962:67;;;6766:34:1;-1:-1:-1;;;;;6836:15:1;;6816:18;;;6809:43;55221:42:0;;56962;;6701:18:1;;56962:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56957:144;;57057:28;;-1:-1:-1;;;57057:28:0;;-1:-1:-1;;;;;6510:32:1;;57057:28:0;;;6492:51:1;6465:18;;57057:28:0;6346:203:1;24128:411:0;24209:13;24225:23;24240:7;24225:14;:23::i;:::-;24209:39;;24273:5;-1:-1:-1;;;;;24267:11:0;:2;-1:-1:-1;;;;;24267:11:0;;;24259:57;;;;-1:-1:-1;;;24259:57:0;;18623:2:1;24259:57:0;;;18605:21:1;18662:2;18642:18;;;18635:30;18701:34;18681:18;;;18674:62;-1:-1:-1;;;18752:18:1;;;18745:31;18793:19;;24259:57:0;18421:397:1;24259:57:0;684:10;-1:-1:-1;;;;;24351:21:0;;;;:62;;-1:-1:-1;24376:37:0;24393:5;684:10;25264:164;:::i;24376:37::-;24329:168;;;;-1:-1:-1;;;24329:168:0;;13904:2:1;24329:168:0;;;13886:21:1;13943:2;13923:18;;;13916:30;13982:34;13962:18;;;13955:62;14053:26;14033:18;;;14026:54;14097:19;;24329:168:0;13702:420:1;24329:168:0;24510:21;24519:2;24523:7;24510:8;:21::i;25495:339::-;25690:41;684:10;25723:7;25690:18;:41::i;:::-;25682:103;;;;-1:-1:-1;;;25682:103:0;;;;;;;:::i;:::-;25798:28;25808:4;25814:2;25818:7;25798:9;:28::i;28983:110::-;29059:26;29069:2;29073:7;29059:26;;;;;;;;;;;;:9;:26::i;2836:173::-;2911:6;;;-1:-1:-1;;;;;2928:17:0;;;-1:-1:-1;;;;;;2928:17:0;;;;;;;2961:40;;2911:6;;;2928:17;2911:6;;2961:40;;2892:16;;2961:40;2881:128;2836:173;:::o;61486:218::-;61569:4;61586:14;61603:29;:4;50716:58;;6203:66:1;50716:58:0;;;6191:79:1;6286:12;;;6279:28;;;50583:7:0;;6323:12:1;;50716:58:0;;;;;;;;;;;;50706:69;;;;;;50699:76;;50514:269;;;;61603:29;61586:46;;61677:19;61692:3;;61677:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;61677:6:0;;:19;-1:-1:-1;;61677:14:0;:19;-1:-1:-1;61677:19:0:i;:::-;61660:13;;-1:-1:-1;;;;;61660:36:0;;;:13;;:36;;61486:218;-1:-1:-1;;;;;61486:218:0:o;24898:295::-;-1:-1:-1;;;;;25001:24:0;;684:10;25001:24;;24993:62;;;;-1:-1:-1;;;24993:62:0;;12330:2:1;24993:62:0;;;12312:21:1;12369:2;12349:18;;;12342:30;12408:27;12388:18;;;12381:55;12453:18;;24993:62:0;12128:349:1;24993:62:0;684:10;25068:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;25068:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;25068:53:0;;;;;;;;;;25137:48;;7496:41:1;;;25068:42:0;;684:10;25137:48;;7469:18:1;25137:48:0;;;;;;;24898:295;;:::o;26161:328::-;26336:41;684:10;26369:7;26336:18;:41::i;:::-;26328:103;;;;-1:-1:-1;;;26328:103:0;;;;;;;:::i;:::-;26442:39;26456:4;26462:2;26466:7;26475:5;26442:13;:39::i;60924:100::-;60976:13;61009:7;61002:14;;;;;:::i;18225:723::-;18281:13;18502:10;18498:53;;-1:-1:-1;;18529:10:0;;;;;;;;;;;;-1:-1:-1;;;18529:10:0;;;;;18225:723::o;18498:53::-;18576:5;18561:12;18617:78;18624:9;;18617:78;;18650:8;;;;:::i;:::-;;-1:-1:-1;18673:10:0;;-1:-1:-1;18681:2:0;18673:10;;:::i;:::-;;;18617:78;;;18705:19;18737:6;18727:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18727:17:0;;18705:39;;18755:154;18762:10;;18755:154;;18789:11;18799:1;18789:11;;:::i;:::-;;-1:-1:-1;18858:10:0;18866:2;18858:5;:10;:::i;:::-;18845:24;;:2;:24;:::i;:::-;18832:39;;18815:6;18822;18815:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;18815:56:0;;;;;;;;-1:-1:-1;18886:11:0;18895:2;18886:11;;:::i;:::-;;;18755:154;;;18933:6;18225:723;-1:-1:-1;;;;18225:723:0:o;31981:174::-;32056:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;32056:29:0;-1:-1:-1;;;;;32056:29:0;;;;;;;;:24;;32110:23;32056:24;32110:14;:23::i;:::-;-1:-1:-1;;;;;32101:46:0;;;;;;;;;;;31981:174;;:::o;28293:348::-;28386:4;28088:16;;;:7;:16;;;;;;-1:-1:-1;;;;;28088:16:0;28403:73;;;;-1:-1:-1;;;28403:73:0;;13087:2:1;28403:73:0;;;13069:21:1;13126:2;13106:18;;;13099:30;13165:34;13145:18;;;13138:62;-1:-1:-1;;;13216:18:1;;;13209:42;13268:19;;28403:73:0;12885:408:1;28403:73:0;28487:13;28503:23;28518:7;28503:14;:23::i;:::-;28487:39;;28556:5;-1:-1:-1;;;;;28545:16:0;:7;-1:-1:-1;;;;;28545:16:0;;:51;;;;28589:7;-1:-1:-1;;;;;28565:31:0;:20;28577:7;28565:11;:20::i;:::-;-1:-1:-1;;;;;28565:31:0;;28545:51;:87;;;-1:-1:-1;;;;;;25385:25:0;;;25361:4;25385:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;28600:32;25264:164;31285:578;31444:4;-1:-1:-1;;;;;31417:31:0;:23;31432:7;31417:14;:23::i;:::-;-1:-1:-1;;;;;31417:31:0;;31409:85;;;;-1:-1:-1;;;31409:85:0;;17797:2:1;31409:85:0;;;17779:21:1;17836:2;17816:18;;;17809:30;17875:34;17855:18;;;17848:62;-1:-1:-1;;;17926:18:1;;;17919:39;17975:19;;31409:85:0;17595:405:1;31409:85:0;-1:-1:-1;;;;;31513:16:0;;31505:65;;;;-1:-1:-1;;;31505:65:0;;11925:2:1;31505:65:0;;;11907:21:1;11964:2;11944:18;;;11937:30;12003:34;11983:18;;;11976:62;-1:-1:-1;;;12054:18:1;;;12047:34;12098:19;;31505:65:0;11723:400:1;31505:65:0;31687:29;31704:1;31708:7;31687:8;:29::i;:::-;-1:-1:-1;;;;;31729:15:0;;;;;;:9;:15;;;;;:20;;31748:1;;31729:15;:20;;31748:1;;31729:20;:::i;:::-;;;;-1:-1:-1;;;;;;;31760:13:0;;;;;;:9;:13;;;;;:18;;31777:1;;31760:13;:18;;31777:1;;31760:18;:::i;:::-;;;;-1:-1:-1;;31789:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;31789:21:0;-1:-1:-1;;;;;31789:21:0;;;;;;;;;31828:27;;31789:16;;31828:27;;;;;;;31285:578;;;:::o;29320:321::-;29450:18;29456:2;29460:7;29450:5;:18::i;:::-;29501:54;29532:1;29536:2;29540:7;29549:5;29501:22;:54::i;:::-;29479:154;;;;-1:-1:-1;;;29479:154:0;;;;;;;:::i;46665:231::-;46743:7;46764:17;46783:18;46805:27;46816:4;46822:9;46805:10;:27::i;:::-;46763:69;;;;46843:18;46855:5;46843:11;:18::i;:::-;-1:-1:-1;46879:9:0;46665:231;-1:-1:-1;;;46665:231:0:o;27371:315::-;27528:28;27538:4;27544:2;27548:7;27528:9;:28::i;:::-;27575:48;27598:4;27604:2;27608:7;27617:5;27575:22;:48::i;:::-;27567:111;;;;-1:-1:-1;;;27567:111:0;;;;;;;:::i;29977:382::-;-1:-1:-1;;;;;30057:16:0;;30049:61;;;;-1:-1:-1;;;30049:61:0;;15963:2:1;30049:61:0;;;15945:21:1;;;15982:18;;;15975:30;16041:34;16021:18;;;16014:62;16093:18;;30049:61:0;15761:356:1;30049:61:0;28064:4;28088:16;;;:7;:16;;;;;;-1:-1:-1;;;;;28088:16:0;:30;30121:58;;;;-1:-1:-1;;;30121:58:0;;11212:2:1;30121:58:0;;;11194:21:1;11251:2;11231:18;;;11224:30;11290;11270:18;;;11263:58;11338:18;;30121:58:0;11010:352:1;30121:58:0;-1:-1:-1;;;;;30250:13:0;;;;;;:9;:13;;;;;:18;;30267:1;;30250:13;:18;;30267:1;;30250:18;:::i;:::-;;;;-1:-1:-1;;30279:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;30279:21:0;-1:-1:-1;;;;;30279:21:0;;;;;;;;30318:33;;30279:16;;;30318:33;;30279:16;;30318:33;29977:382;;:::o;32720:799::-;32875:4;-1:-1:-1;;;;;32896:13:0;;10987:20;11035:8;32892:620;;32932:72;;-1:-1:-1;;;32932:72:0;;-1:-1:-1;;;;;32932:36:0;;;;;:72;;684:10;;32983:4;;32989:7;;32998:5;;32932:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;32932:72:0;;;;;;;;-1:-1:-1;;32932:72:0;;;;;;;;;;;;:::i;:::-;;;32928:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;33174:13:0;;33170:272;;33217:60;;-1:-1:-1;;;33217:60:0;;;;;;;:::i;33170:272::-;33392:6;33386:13;33377:6;33373:2;33369:15;33362:38;32928:529;-1:-1:-1;;;;;;33055:51:0;-1:-1:-1;;;33055:51:0;;-1:-1:-1;33048:58:0;;32892:620;-1:-1:-1;33496:4:0;32720:799;;;;;;:::o;44555:1308::-;44636:7;44645:12;44870:9;:16;44890:2;44870:22;44866:990;;;45166:4;45151:20;;45145:27;45216:4;45201:20;;45195:27;45274:4;45259:20;;45253:27;44909:9;45245:36;45317:25;45328:4;45245:36;45145:27;45195;45317:10;:25::i;:::-;45310:32;;;;;;;;;44866:990;45364:9;:16;45384:2;45364:22;45360:496;;;45639:4;45624:20;;45618:27;45690:4;45675:20;;45669:27;45732:23;45743:4;45618:27;45669;45732:10;:23::i;:::-;45725:30;;;;;;;;45360:496;-1:-1:-1;45804:1:0;;-1:-1:-1;45808:35:0;45360:496;44555:1308;;;;;:::o;42826:643::-;42904:20;42895:5;:29;;;;;;;;:::i;:::-;;42891:571;;;42826:643;:::o;42891:571::-;43002:29;42993:5;:38;;;;;;;;:::i;:::-;;42989:473;;;43048:34;;-1:-1:-1;;;43048:34:0;;8617:2:1;43048:34:0;;;8599:21:1;8656:2;8636:18;;;8629:30;8695:26;8675:18;;;8668:54;8739:18;;43048:34:0;8415:348:1;42989:473:0;43113:35;43104:5;:44;;;;;;;;:::i;:::-;;43100:362;;;43165:41;;-1:-1:-1;;;43165:41:0;;9325:2:1;43165:41:0;;;9307:21:1;9364:2;9344:18;;;9337:30;9403:33;9383:18;;;9376:61;9454:18;;43165:41:0;9123:355:1;43100:362:0;43237:30;43228:5;:39;;;;;;;;:::i;:::-;;43224:238;;;43284:44;;-1:-1:-1;;;43284:44:0;;12684:2:1;43284:44:0;;;12666:21:1;12723:2;12703:18;;;12696:30;12762:34;12742:18;;;12735:62;-1:-1:-1;;;12813:18:1;;;12806:32;12855:19;;43284:44:0;12482:398:1;43224:238:0;43359:30;43350:5;:39;;;;;;;;:::i;:::-;;43346:116;;;43406:44;;-1:-1:-1;;;43406:44:0;;15560:2:1;43406:44:0;;;15542:21:1;15599:2;15579:18;;;15572:30;15638:34;15618:18;;;15611:62;-1:-1:-1;;;15689:18:1;;;15682:32;15731:19;;43406:44:0;15358:398:1;48164:1632:0;48295:7;;49229:66;49216:79;;49212:163;;;-1:-1:-1;49328:1:0;;-1:-1:-1;49332:30:0;49312:51;;49212:163;49389:1;:7;;49394:2;49389:7;;:18;;;;;49400:1;:7;;49405:2;49400:7;;49389:18;49385:102;;;-1:-1:-1;49440:1:0;;-1:-1:-1;49444:30:0;49424:51;;49385:102;49601:24;;;49584:14;49601:24;;;;;;;;;7775:25:1;;;7848:4;7836:17;;7816:18;;;7809:45;;;;7870:18;;;7863:34;;;7913:18;;;7906:34;;;49601:24:0;;7747:19:1;;49601:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;49601:24:0;;-1:-1:-1;;49601:24:0;;;-1:-1:-1;;;;;;;49640:20:0;;49636:103;;49693:1;49697:29;49677:50;;;;;;;49636:103;49759:6;-1:-1:-1;49767:20:0;;-1:-1:-1;48164:1632:0;;;;;;;;:::o;47159:391::-;47273:7;;-1:-1:-1;;;;;47374:75:0;;47476:3;47472:12;;;47486:2;47468:21;47517:25;47528:4;47468:21;47537:1;47374:75;47517:10;:25::i;:::-;47510:32;;;;;;47159:391;;;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:631:1;78:5;108:18;149:2;141:6;138:14;135:40;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:72;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:45;;;532:1;529;522:12;491:45;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;14:631;;;;;:::o;650:173::-;718:20;;-1:-1:-1;;;;;767:31:1;;757:42;;747:70;;813:1;810;803:12;747:70;650:173;;;:::o;828:186::-;887:6;940:2;928:9;919:7;915:23;911:32;908:52;;;956:1;953;946:12;908:52;979:29;998:9;979:29;:::i;1019:260::-;1087:6;1095;1148:2;1136:9;1127:7;1123:23;1119:32;1116:52;;;1164:1;1161;1154:12;1116:52;1187:29;1206:9;1187:29;:::i;:::-;1177:39;;1235:38;1269:2;1258:9;1254:18;1235:38;:::i;:::-;1225:48;;1019:260;;;;;:::o;1284:328::-;1361:6;1369;1377;1430:2;1418:9;1409:7;1405:23;1401:32;1398:52;;;1446:1;1443;1436:12;1398:52;1469:29;1488:9;1469:29;:::i;:::-;1459:39;;1517:38;1551:2;1540:9;1536:18;1517:38;:::i;:::-;1507:48;;1602:2;1591:9;1587:18;1574:32;1564:42;;1284:328;;;;;:::o;1617:666::-;1712:6;1720;1728;1736;1789:3;1777:9;1768:7;1764:23;1760:33;1757:53;;;1806:1;1803;1796:12;1757:53;1829:29;1848:9;1829:29;:::i;:::-;1819:39;;1877:38;1911:2;1900:9;1896:18;1877:38;:::i;:::-;1867:48;;1962:2;1951:9;1947:18;1934:32;1924:42;;2017:2;2006:9;2002:18;1989:32;2044:18;2036:6;2033:30;2030:50;;;2076:1;2073;2066:12;2030:50;2099:22;;2152:4;2144:13;;2140:27;-1:-1:-1;2130:55:1;;2181:1;2178;2171:12;2130:55;2204:73;2269:7;2264:2;2251:16;2246:2;2242;2238:11;2204:73;:::i;:::-;2194:83;;;1617:666;;;;;;;:::o;2288:315::-;2353:6;2361;2414:2;2402:9;2393:7;2389:23;2385:32;2382:52;;;2430:1;2427;2420:12;2382:52;2453:29;2472:9;2453:29;:::i;:::-;2443:39;;2532:2;2521:9;2517:18;2504:32;2545:28;2567:5;2545:28;:::i;:::-;2592:5;2582:15;;;2288:315;;;;;:::o;2608:254::-;2676:6;2684;2737:2;2725:9;2716:7;2712:23;2708:32;2705:52;;;2753:1;2750;2743:12;2705:52;2776:29;2795:9;2776:29;:::i;:::-;2766:39;2852:2;2837:18;;;;2824:32;;-1:-1:-1;;;2608:254:1:o;2867:245::-;2934:6;2987:2;2975:9;2966:7;2962:23;2958:32;2955:52;;;3003:1;3000;2993:12;2955:52;3035:9;3029:16;3054:28;3076:5;3054:28;:::i;3117:245::-;3175:6;3228:2;3216:9;3207:7;3203:23;3199:32;3196:52;;;3244:1;3241;3234:12;3196:52;3283:9;3270:23;3302:30;3326:5;3302:30;:::i;3367:249::-;3436:6;3489:2;3477:9;3468:7;3464:23;3460:32;3457:52;;;3505:1;3502;3495:12;3457:52;3537:9;3531:16;3556:30;3580:5;3556:30;:::i;3621:450::-;3690:6;3743:2;3731:9;3722:7;3718:23;3714:32;3711:52;;;3759:1;3756;3749:12;3711:52;3799:9;3786:23;3832:18;3824:6;3821:30;3818:50;;;3864:1;3861;3854:12;3818:50;3887:22;;3940:4;3932:13;;3928:27;-1:-1:-1;3918:55:1;;3969:1;3966;3959:12;3918:55;3992:73;4057:7;4052:2;4039:16;4034:2;4030;4026:11;3992:73;:::i;4076:180::-;4135:6;4188:2;4176:9;4167:7;4163:23;4159:32;4156:52;;;4204:1;4201;4194:12;4156:52;-1:-1:-1;4227:23:1;;4076:180;-1:-1:-1;4076:180:1:o;4261:659::-;4340:6;4348;4356;4409:2;4397:9;4388:7;4384:23;4380:32;4377:52;;;4425:1;4422;4415:12;4377:52;4461:9;4448:23;4438:33;;4522:2;4511:9;4507:18;4494:32;4545:18;4586:2;4578:6;4575:14;4572:34;;;4602:1;4599;4592:12;4572:34;4640:6;4629:9;4625:22;4615:32;;4685:7;4678:4;4674:2;4670:13;4666:27;4656:55;;4707:1;4704;4697:12;4656:55;4747:2;4734:16;4773:2;4765:6;4762:14;4759:34;;;4789:1;4786;4779:12;4759:34;4834:7;4829:2;4820:6;4816:2;4812:15;4808:24;4805:37;4802:57;;;4855:1;4852;4845:12;4802:57;4886:2;4882;4878:11;4868:21;;4908:6;4898:16;;;;;4261:659;;;;;:::o;4925:257::-;4966:3;5004:5;4998:12;5031:6;5026:3;5019:19;5047:63;5103:6;5096:4;5091:3;5087:14;5080:4;5073:5;5069:16;5047:63;:::i;:::-;5164:2;5143:15;-1:-1:-1;;5139:29:1;5130:39;;;;5171:4;5126:50;;4925:257;-1:-1:-1;;4925:257:1:o;5486:470::-;5665:3;5703:6;5697:13;5719:53;5765:6;5760:3;5753:4;5745:6;5741:17;5719:53;:::i;:::-;5835:13;;5794:16;;;;5857:57;5835:13;5794:16;5891:4;5879:17;;5857:57;:::i;:::-;5930:20;;5486:470;-1:-1:-1;;;;5486:470:1:o;6863:488::-;-1:-1:-1;;;;;7132:15:1;;;7114:34;;7184:15;;7179:2;7164:18;;7157:43;7231:2;7216:18;;7209:34;;;7279:3;7274:2;7259:18;;7252:31;;;7057:4;;7300:45;;7325:19;;7317:6;7300:45;:::i;:::-;7292:53;6863:488;-1:-1:-1;;;;;;6863:488:1:o;8191:219::-;8340:2;8329:9;8322:21;8303:4;8360:44;8400:2;8389:9;8385:18;8377:6;8360:44;:::i;10184:414::-;10386:2;10368:21;;;10425:2;10405:18;;;10398:30;10464:34;10459:2;10444:18;;10437:62;-1:-1:-1;;;10530:2:1;10515:18;;10508:48;10588:3;10573:19;;10184:414::o;17234:356::-;17436:2;17418:21;;;17455:18;;;17448:30;17514:34;17509:2;17494:18;;17487:62;17581:2;17566:18;;17234:356::o;19176:413::-;19378:2;19360:21;;;19417:2;19397:18;;;19390:30;19456:34;19451:2;19436:18;;19429:62;-1:-1:-1;;;19522:2:1;19507:18;;19500:47;19579:3;19564:19;;19176:413::o;20187:128::-;20227:3;20258:1;20254:6;20251:1;20248:13;20245:39;;;20264:18;;:::i;:::-;-1:-1:-1;20300:9:1;;20187:128::o;20320:120::-;20360:1;20386;20376:35;;20391:18;;:::i;:::-;-1:-1:-1;20425:9:1;;20320:120::o;20445:168::-;20485:7;20551:1;20547;20543:6;20539:14;20536:1;20533:21;20528:1;20521:9;20514:17;20510:45;20507:71;;;20558:18;;:::i;:::-;-1:-1:-1;20598:9:1;;20445:168::o;20618:125::-;20658:4;20686:1;20683;20680:8;20677:34;;;20691:18;;:::i;:::-;-1:-1:-1;20728:9:1;;20618:125::o;20748:258::-;20820:1;20830:113;20844:6;20841:1;20838:13;20830:113;;;20920:11;;;20914:18;20901:11;;;20894:39;20866:2;20859:10;20830:113;;;20961:6;20958:1;20955:13;20952:48;;;-1:-1:-1;;20996:1:1;20978:16;;20971:27;20748:258::o;21011:380::-;21090:1;21086:12;;;;21133;;;21154:61;;21208:4;21200:6;21196:17;21186:27;;21154:61;21261:2;21253:6;21250:14;21230:18;21227:38;21224:161;;;21307:10;21302:3;21298:20;21295:1;21288:31;21342:4;21339:1;21332:15;21370:4;21367:1;21360:15;21224:161;;21011:380;;;:::o;21396:135::-;21435:3;-1:-1:-1;;21456:17:1;;21453:43;;;21476:18;;:::i;:::-;-1:-1:-1;21523:1:1;21512:13;;21396:135::o;21536:112::-;21568:1;21594;21584:35;;21599:18;;:::i;:::-;-1:-1:-1;21633:9:1;;21536:112::o;21653:127::-;21714:10;21709:3;21705:20;21702:1;21695:31;21745:4;21742:1;21735:15;21769:4;21766:1;21759:15;21785:127;21846:10;21841:3;21837:20;21834:1;21827:31;21877:4;21874:1;21867:15;21901:4;21898:1;21891:15;21917:127;21978:10;21973:3;21969:20;21966:1;21959:31;22009:4;22006:1;21999:15;22033:4;22030:1;22023:15;22049:127;22110:10;22105:3;22101:20;22098:1;22091:31;22141:4;22138:1;22131:15;22165:4;22162:1;22155:15;22181:127;22242:10;22237:3;22233:20;22230:1;22223:31;22273:4;22270:1;22263:15;22297:4;22294:1;22287:15;22313:118;22399:5;22392:13;22385:21;22378:5;22375:32;22365:60;;22421:1;22418;22411:12;22436:131;-1:-1:-1;;;;;;22510:32:1;;22500:43;;22490:71;;22557:1;22554;22547:12

Swarm Source

ipfs://8fc7a61292f0693797343da98922f86c7094971d039a8d8afe72863cfdb8584d

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