Token

Quaks (QUAK)

ERC-721

Overview

Max Total Supply

6,000 QUAK

Holders

1,482

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x07bbdaf30e89ea3ecf6cadc80d6e7c4b0843c729

Filtered by Token Holder

0x6E833922B345Fd3055daAb1e43d45e77C5C97efC

neverninetofive.eth

Balance

4 QUAK

0x6e833922b345fd3055daab1e43d45e77c5c97efc

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Quaks

Compiler Version

v0.7.6+commit.7338295f

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-08-24
*/

/**
 *Submitted for verification at Etherscan.io on 2021-08-16
*/

// SPDX-License-Identifier: MIT
 
// File: @openzeppelin/contracts/utils/Context.sol

pragma solidity >=0.6.0 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN 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 payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

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



pragma solidity >=0.6.0 <0.8.0;

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

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



pragma solidity >=0.6.2 <0.8.0;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

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

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

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

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

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
      * @dev Safely transfers `tokenId` token from `from` to `to`.
      *
      * Requirements:
      *
      * - `from` cannot be the zero address.
      * - `to` cannot be the zero address.
      * - `tokenId` token must exist and be owned by `from`.
      * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
      * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
      *
      * Emits a {Transfer} event.
      */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}

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



pragma solidity >=0.6.2 <0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {

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

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

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

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



pragma solidity >=0.6.2 <0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

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

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

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



pragma solidity >=0.6.0 <0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}

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



pragma solidity >=0.6.0 <0.8.0;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
abstract contract ERC165 is IERC165 {
    /*
     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
     */
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;

    /**
     * @dev Mapping of interface ids to whether or not it's supported.
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    constructor () {
        // Derived contracts need only register support for their own interfaces,
        // we register support for ERC165 itself here
        _registerInterface(_INTERFACE_ID_ERC165);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     *
     * Time complexity O(1), guaranteed to always use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return _supportedInterfaces[interfaceId];
    }

    /**
     * @dev Registers the contract as an implementer of the interface defined by
     * `interfaceId`. Support of the actual ERC165 interface is automatic and
     * registering its interface id is not required.
     *
     * See {IERC165-supportsInterface}.
     *
     * Requirements:
     *
     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
     */
    function _registerInterface(bytes4 interfaceId) internal virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

// File: @openzeppelin/contracts/math/SafeMath.sol



pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
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) {
        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) {
        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) {
        // 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) {
        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) {
        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) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @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) {
        require(b <= a, "SafeMath: subtraction overflow");
        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) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @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. 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) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        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) {
        require(b > 0, "SafeMath: modulo by zero");
        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) {
        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.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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) {
        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) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

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



pragma solidity >=0.6.2 <0.8.0;

/**
 * @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;
        // solhint-disable-next-line no-inline-assembly
        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");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private 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

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

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



pragma solidity >=0.6.0 <0.8.0;

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

    struct Set {
        // Storage of set values
        bytes32[] _values;

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

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

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

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

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

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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



pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Library for managing an enumerable variant of Solidity's
 * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
 * type.
 *
 * Maps have the following properties:
 *
 * - Entries are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Entries are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 *
 * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are
 * supported.
 */
library EnumerableMap {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

    struct Map {
        // Storage of map keys and values
        MapEntry[] _entries;

        // Position of the entry defined by a key in the `entries` array, plus 1
        // because index 0 means a key is not in the map.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex == 0) { // Equivalent to !contains(map, key)
            map._entries.push(MapEntry({ _key: key, _value: value }));
            // The entry is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            map._indexes[key] = map._entries.length;
            return true;
        } else {
            map._entries[keyIndex - 1]._value = value;
            return false;
        }
    }

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

        if (keyIndex != 0) { // Equivalent to contains(map, key)
            // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one
            // in the array, and then remove the last entry (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = keyIndex - 1;
            uint256 lastIndex = map._entries.length - 1;

            // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            MapEntry storage lastEntry = map._entries[lastIndex];

            // Move the last entry to the index where the entry to delete is
            map._entries[toDeleteIndex] = lastEntry;
            // Update the index for the moved entry
            map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved entry was stored
            map._entries.pop();

            // Delete the index for the deleted slot
            delete map._indexes[key];

            return true;
        } else {
            return false;
        }
    }

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

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function _length(Map storage map) private view returns (uint256) {
        return map._entries.length;
    }

   /**
    * @dev Returns the key-value pair stored at position `index` in the map. O(1).
    *
    * Note that there are no guarantees on the ordering of entries inside the
    * array, and it may change when more entries are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
        require(map._entries.length > index, "EnumerableMap: index out of bounds");

        MapEntry storage entry = map._entries[index];
        return (entry._key, entry._value);
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     */
    function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
        uint256 keyIndex = map._indexes[key];
        if (keyIndex == 0) return (false, 0); // Equivalent to contains(map, key)
        return (true, map._entries[keyIndex - 1]._value); // All indexes are 1-based
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, "EnumerableMap: nonexistent key"); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {_tryGet}.
     */
    function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
        return _set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
    }

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

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

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

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

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     *
     * _Available since v3.4._
     */
    function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
        (bool success, bytes32 value) = _tryGet(map._inner, bytes32(key));
        return (success, address(uint160(uint256(value))));
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key)))));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage))));
    }
}

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



pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    /**
     * @dev Converts a `uint256` to its ASCII `string` 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);
        uint256 index = digits - 1;
        temp = value;
        while (temp != 0) {
            buffer[index--] = bytes1(uint8(48 + temp % 10));
            temp /= 10;
        }
        return string(buffer);
    }
}

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



pragma solidity >=0.6.0 <0.8.0;

/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
 
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
    using SafeMath for uint256;
    using Address for address;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableMap for EnumerableMap.UintToAddressMap;
    using Strings for uint256;

    // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
    // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
    bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;

    // Mapping from holder address to their (enumerable) set of owned tokens
    mapping (address => EnumerableSet.UintSet) private _holderTokens;

    // Enumerable mapping from token ids to their owners
    EnumerableMap.UintToAddressMap private _tokenOwners;

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Optional mapping for token URIs
    mapping (uint256 => string) private _tokenURIs;

    // Base URI
    string private _baseURI;

    /*
     *     bytes4(keccak256('balanceOf(address)')) == 0x70a08231
     *     bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
     *     bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
     *     bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
     *     bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
     *     bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
     *     bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
     *
     *     => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
     *        0xa22cb465 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
     */
    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;

    /*
     *     bytes4(keccak256('name()')) == 0x06fdde03
     *     bytes4(keccak256('symbol()')) == 0x95d89b41
     *     bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd
     *
     *     => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f
     */
    bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;

    /*
     *     bytes4(keccak256('totalSupply()')) == 0x18160ddd
     *     bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59
     *     bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7
     *
     *     => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63
     */
    bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;

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

        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721);
        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
        _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
    }

    /**
     * @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 _holderTokens[owner].length();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
    }

    /**
     * @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 _tokenURI = _tokenURIs[tokenId];
        string memory base = baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI));
        }
        // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
        return string(abi.encodePacked(base, tokenId.toString()));
    }

    /**
    * @dev Returns the base URI set via {_setBaseURI}. This will be
    * automatically added as a prefix in {tokenURI} to each token's URI, or
    * to the token ID if no specific URI is set for that token ID.
    */
    function baseURI() public view virtual returns (string memory) {
        return _baseURI;
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        return _holderTokens[owner].at(index);
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _tokenOwners.length();
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        (uint256 tokenId, ) = _tokenOwners.at(index);
        return tokenId;
    }

    /**
     * @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 || ERC721.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 _tokenOwners.contains(tokenId);
    }

    /**
     * @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 || ERC721.isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     d*
     * - `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);

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(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); // internal owner

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

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

        // Clear metadata (if any)
        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(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"); // internal owner
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

        _holderTokens[from].remove(tokenId);
        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @dev Internal function to set the base URI for all token IDs. It is
     * automatically added as a prefix to the value returned in {tokenURI},
     * or to the token ID if {tokenURI} is empty.
     */
    function _setBaseURI(string memory baseURI_) internal virtual {
        _baseURI = baseURI_;
    }

    /**
     * @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()) {
            return true;
        }
        bytes memory returndata = to.functionCall(abi.encodeWithSelector(
            IERC721Receiver(to).onERC721Received.selector,
            _msgSender(),
            from,
            tokenId,
            _data
        ), "ERC721: transfer to non ERC721Receiver implementer");
        bytes4 retval = abi.decode(returndata, (bytes4));
        return (retval == _ERC721_RECEIVED);
    }

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

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

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



pragma solidity >=0.6.0 <0.8.0;

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), 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 {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}




// website (https://quaks.xyz)




pragma solidity >=0.6.0 <0.8.0;
pragma abicoder v2;

contract Quaks is ERC721, Ownable {
    using SafeMath for uint256;
    string public quaks_PROVENANCE = ""; //after sold out
    string public LICENSE_TEXT = ""; // license text
    bool licenseLocked = false; 
    uint256 public quaksPrice = 10000000000000000; // 0.01 ETH
    uint public constant maxquaksPurchase = 20;
    uint256 public constant MAX_quaks = 6000;
    bool public saleIsActive = false;
    mapping(uint => string) public quaksNames;
    uint public quaksReserve = 500; // for events and giveaways
    event quaksNameChange(address _by, uint _tokenId, string _name);
    event licenseisLocked(string _licenseText);
    
    constructor() ERC721("Quaks", "QUAK") {
        setBaseURI("https://www.quaks.xyz/api/");
    }

    function withdraw() public onlyOwner {
        uint balance = address(this).balance;
        msg.sender.transfer(balance);
    }
    
    function _Price(uint256 newPrice) public onlyOwner {
        quaksPrice = newPrice;
    }
    
    function mintquaks(uint numberOfTokens) public payable {
        require(saleIsActive, "Sale must be active to mint quaks");
        require(numberOfTokens > 0 && numberOfTokens <= maxquaksPurchase, "Can only mint 20 tokens at a time");
        require(totalSupply().add(numberOfTokens) <= MAX_quaks, "Purchase would exceed max supply of quaks");
        require(msg.value >= quaksPrice.mul(numberOfTokens), "Ether value sent is not correct");
        for(uint i = 0; i < numberOfTokens; i++) {
            uint mintIndex = totalSupply();
            if (totalSupply() < MAX_quaks) {
                _safeMint(msg.sender, mintIndex);
            }
        }
    }
     
    function changequaksName(uint _tokenId, string memory _name) public {
        require(ownerOf(_tokenId) == msg.sender, "Hey, your wallet doesn't own this quaks!");
        require(sha256(bytes(_name)) != sha256(bytes(quaksNames[_tokenId])), "New name is same as the current one");
        quaksNames[_tokenId] = _name;
        emit quaksNameChange(msg.sender, _tokenId, _name);
    }
    
    function viewquaksName(uint _tokenId) public view returns( string memory ){
        require( _tokenId < totalSupply(), "Choose a quaks within range" );
        return quaksNames[_tokenId];
    }
    
    function quaksNamesOfOwner(address _owner) external view returns(string[] memory ) {
        uint256 tokenCount = balanceOf(_owner);
        if (tokenCount == 0) {
            // Return an empty array
            return new string[](0);
        } else {
            string[] memory result = new string[](tokenCount);
            uint256 index;
            for (index = 0; index < tokenCount; index++) {
                result[index] = quaksNames[ tokenOfOwnerByIndex(_owner, index) ] ;
            }
            return result;
        }
    }
    
    function reservequaks(address _to, uint256 _reserveAmount) public onlyOwner {        
        uint supply = totalSupply();
        require(_reserveAmount > 0 && _reserveAmount <= quaksReserve, "Not enough reserve left for team");
        for (uint i = 0; i < _reserveAmount; i++) {
            _safeMint(_to, supply + i);
        }
        quaksReserve = quaksReserve.sub(_reserveAmount);
    }

    function setProvenanceHash(string memory provenanceHash) public onlyOwner {
        quaks_PROVENANCE = provenanceHash;
    }

    function setBaseURI(string memory baseURI) public onlyOwner {
        _setBaseURI(baseURI);
    }

    function tokensOfOwner(address _owner) external view returns(uint256[] memory ) {
        uint256 tokenCount = balanceOf(_owner);
        if (tokenCount == 0) {
            return new uint256[](0);
        } else {
            uint256[] memory result = new uint256[](tokenCount);
            uint256 index;
            for (index = 0; index < tokenCount; index++) {
                result[index] = tokenOfOwnerByIndex(_owner, index);
            }
            return result;
        }
    }
    
    function tokenLicense(uint _id) public view returns(string memory) {
        require(_id < totalSupply(), "Choose quaks Within Range");
        return LICENSE_TEXT;
    }
    
    function lockLicense() public onlyOwner {
        licenseLocked =  true;
        emit licenseisLocked(LICENSE_TEXT);
    }
    
    function changeLicense(string memory _license) public onlyOwner {
        require(licenseLocked == false, "License already locked");
        LICENSE_TEXT = _license;
    }
    
    function flipSaleState() public onlyOwner {
        saleIsActive = !saleIsActive;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"_licenseText","type":"string"}],"name":"licenseisLocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_by","type":"address"},{"indexed":false,"internalType":"uint256","name":"_tokenId","type":"uint256"},{"indexed":false,"internalType":"string","name":"_name","type":"string"}],"name":"quaksNameChange","type":"event"},{"inputs":[],"name":"LICENSE_TEXT","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_quaks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"_Price","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_license","type":"string"}],"name":"changeLicense","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"string","name":"_name","type":"string"}],"name":"changequaksName","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"flipSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockLicense","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxquaksPurchase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"mintquaks","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"quaksNames","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"quaksNamesOfOwner","outputs":[{"internalType":"string[]","name":"","type":"string[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"quaksPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"quaksReserve","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"quaks_PROVENANCE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_reserveAmount","type":"uint256"}],"name":"reservequaks","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"provenanceHash","type":"string"}],"name":"setProvenanceHash","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":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"tokenLicense","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"viewquaksName","outputs":[{"internalType":"string","name":"","type":"string"}],"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

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

Deployed Bytecode Sourcemap

66934:4636:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10298:150;;;;;;;;;;-1:-1:-1;10298:150:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51576:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;54362:221::-;;;;;;;;;;-1:-1:-1;54362:221:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;53892:404::-;;;;;;;;;;-1:-1:-1;53892:404:0;;;;;:::i;:::-;;:::i;:::-;;70215:126;;;;;;;;;;-1:-1:-1;70215:126:0;;;;;:::i;:::-;;:::i;69239:555::-;;;;;;;;;;-1:-1:-1;69239:555:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;67354:41::-;;;;;;;;;;-1:-1:-1;67354:41:0;;;;;:::i;:::-;;:::i;68630:388::-;;;;;;;;;;-1:-1:-1;68630:388:0;;;;;:::i;:::-;;:::i;53370:211::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;55252:305::-;;;;;;;;;;-1:-1:-1;55252:305:0;;;;;:::i;:::-;;:::i;53132:162::-;;;;;;;;;;-1:-1:-1;53132:162:0;;;;;:::i;:::-;;:::i;71478:89::-;;;;;;;;;;;;;:::i;67697:131::-;;;;;;;;;;;;;:::i;55628:151::-;;;;;;;;;;-1:-1:-1;55628:151:0;;;;;:::i;:::-;;:::i;53658:172::-;;;;;;;;;;-1:-1:-1;53658:172:0;;;;;:::i;:::-;;:::i;67943:674::-;;;;;;:::i;:::-;;:::i;70349:99::-;;;;;;;;;;-1:-1:-1;70349:99:0;;;;;:::i;:::-;;:::i;67155:45::-;;;;;;;;;;;;;:::i;51332:177::-;;;;;;;;;;-1:-1:-1;51332:177:0;;;;;:::i;:::-;;:::i;52951:97::-;;;;;;;;;;;;;:::i;51049:221::-;;;;;;;;;;-1:-1:-1;51049:221:0;;;;;:::i;:::-;;:::i;66278:148::-;;;;;;;;;;;;;:::i;70456:502::-;;;;;;;;;;-1:-1:-1;70456:502:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;65627:87::-;;;;;;;;;;;;;:::i;51745:104::-;;;;;;;;;;;;;:::i;67067:31::-;;;;;;;;;;;;;:::i;67219:42::-;;;;;;;;;;;;;:::i;54655:295::-;;;;;;;;;;-1:-1:-1;54655:295:0;;;;;:::i;:::-;;:::i;69806:401::-;;;;;;;;;;-1:-1:-1;69806:401:0;;;;;:::i;:::-;;:::i;67008:35::-;;;;;;;;;;;;;:::i;71292:174::-;;;;;;;;;;-1:-1:-1;71292:174:0;;;;;:::i;:::-;;:::i;55850:285::-;;;;;;;;;;-1:-1:-1;55850:285:0;;;;;:::i;:::-;;:::i;71155:125::-;;;;;;;;;;;;;:::i;67268:40::-;;;;;;;;;;;;;:::i;67840:91::-;;;;;;;;;;-1:-1:-1;67840:91:0;;;;;:::i;:::-;;:::i;67402:30::-;;;;;;;;;;;;;:::i;51920:792::-;;;;;;;;;;-1:-1:-1;51920:792:0;;;;;:::i;:::-;;:::i;70970:173::-;;;;;;;;;;-1:-1:-1;70970:173:0;;;;;:::i;:::-;;:::i;55021:164::-;;;;;;;;;;-1:-1:-1;55021:164:0;;;;;:::i;:::-;;:::i;67315:32::-;;;;;;;;;;;;;:::i;69030:197::-;;;;;;;;;;-1:-1:-1;69030:197:0;;;;;:::i;:::-;;:::i;66581:244::-;;;;;;;;;;-1:-1:-1;66581:244:0;;;;;:::i;:::-;;:::i;10298:150::-;-1:-1:-1;;;;;;10407:33:0;;10383:4;10407:33;;;;;;;;;;;;;10298:150;;;;:::o;51576:100::-;51663:5;51656:12;;;;;;;;-1:-1:-1;;51656:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51630:13;;51656:12;;51663:5;;51656:12;;51663:5;51656:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51576:100;:::o;54362:221::-;54438:7;54466:16;54474:7;54466;:16::i;:::-;54458:73;;;;-1:-1:-1;;;54458:73:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;54551:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;54551:24:0;;54362:221::o;53892:404::-;53973:13;53989:23;54004:7;53989:14;:23::i;:::-;53973:39;;54037:5;-1:-1:-1;;;;;54031:11:0;:2;-1:-1:-1;;;;;54031:11:0;;;54023:57;;;;-1:-1:-1;;;54023:57:0;;;;;;;:::i;:::-;54117:5;-1:-1:-1;;;;;54101:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;54101:21:0;;:69;;;;54126:44;54150:5;54157:12;:10;:12::i;54126:44::-;54093:161;;;;-1:-1:-1;;;54093:161:0;;;;;;;:::i;:::-;54267:21;54276:2;54280:7;54267:8;:21::i;:::-;53892:404;;;:::o;70215:126::-;65858:12;:10;:12::i;:::-;-1:-1:-1;;;;;65847:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65847:23:0;;65839:68;;;;-1:-1:-1;;;65839:68:0;;;;;;;:::i;:::-;70300:33;;::::1;::::0;:16:::1;::::0;:33:::1;::::0;::::1;::::0;::::1;:::i;:::-;;70215:126:::0;:::o;69239:555::-;69304:15;69333:18;69354:17;69364:6;69354:9;:17::i;:::-;69333:38;-1:-1:-1;69386:15:0;69382:405;;69463:15;;;69476:1;69463:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69456:22;;;;;69382:405;69511:22;69549:10;69536:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69511:49;;69575:13;69603:145;69627:10;69619:5;:18;69603:145;;;69683:10;:48;69695:34;69715:6;69723:5;69695:19;:34::i;:::-;69683:48;;;;;;;;;;;;;;-1:-1:-1;69683:48:0;69667:64;;;;;;;;;;;-1:-1:-1;;69667:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;69683:48;;69667:64;;;69683:48;69667:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:6;69674:5;69667:13;;;;;;;;;;;;;;;;;:64;69639:7;;69603:145;;;-1:-1:-1;69769:6:0;-1:-1:-1;69762:13:0;;-1:-1:-1;69762:13:0;67354:41;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;67354:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;68630:388::-;68738:10;68717:17;68725:8;68717:7;:17::i;:::-;-1:-1:-1;;;;;68717:31:0;;68709:84;;;;-1:-1:-1;;;68709:84:0;;;;;;;:::i;:::-;68849:20;;;;:10;:20;;;;;;;68836:35;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;68812:20;68825:5;68812:20;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:59;;68804:107;;;;-1:-1:-1;;;68804:107:0;;;;;;;:::i;:::-;68922:20;;;;:10;:20;;;;;;;;:28;;;;;;;;:::i;:::-;;68966:44;68982:10;68994:8;69004:5;68966:44;;;;;;;;:::i;:::-;;;;;;;;68630:388;;:::o;53370:211::-;53431:7;53552:21;:12;:19;:21::i;:::-;53545:28;;53370:211;:::o;55252:305::-;55413:41;55432:12;:10;:12::i;:::-;55446:7;55413:18;:41::i;:::-;55405:103;;;;-1:-1:-1;;;55405:103:0;;;;;;;:::i;:::-;55521:28;55531:4;55537:2;55541:7;55521:9;:28::i;53132:162::-;-1:-1:-1;;;;;53256:20:0;;53229:7;53256:20;;;:13;:20;;;;;:30;;53280:5;53256:23;:30::i;:::-;53249:37;;53132:162;;;;;:::o;71478:89::-;65858:12;:10;:12::i;:::-;-1:-1:-1;;;;;65847:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65847:23:0;;65839:68;;;;-1:-1:-1;;;65839:68:0;;;;;;;:::i;:::-;71547:12:::1;::::0;;-1:-1:-1;;71531:28:0;::::1;71547:12;::::0;;::::1;71546:13;71531:28;::::0;;71478:89::o;67697:131::-;65858:12;:10;:12::i;:::-;-1:-1:-1;;;;;65847:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65847:23:0;;65839:68;;;;-1:-1:-1;;;65839:68:0;;;;;;;:::i;:::-;67792:28:::1;::::0;67760:21:::1;::::0;67792:10:::1;::::0;:28;::::1;;;::::0;67760:21;;67745:12:::1;67792:28:::0;67745:12;67792:28;67760:21;67792:10;:28;::::1;;;;;;;;;;;;;::::0;::::1;;;;55628:151:::0;55732:39;55749:4;55755:2;55759:7;55732:39;;;;;;;;;;;;:16;:39::i;53658:172::-;53733:7;;53775:22;:12;53791:5;53775:15;:22::i;:::-;-1:-1:-1;53753:44:0;53658:172;-1:-1:-1;;;53658:172:0:o;67943:674::-;68017:12;;;;68009:58;;;;-1:-1:-1;;;68009:58:0;;;;;;;:::i;:::-;68103:1;68086:14;:18;:56;;;;;67259:2;68108:14;:34;;68086:56;68078:102;;;;-1:-1:-1;;;68078:102:0;;;;;;;:::i;:::-;67304:4;68199:33;68217:14;68199:13;:11;:13::i;:::-;:17;;:33::i;:::-;:46;;68191:100;;;;-1:-1:-1;;;68191:100:0;;;;;;;:::i;:::-;68323:10;;:30;;68338:14;68323;:30::i;:::-;68310:9;:43;;68302:87;;;;-1:-1:-1;;;68302:87:0;;;;;;;:::i;:::-;68404:6;68400:210;68420:14;68416:1;:18;68400:210;;;68456:14;68473:13;:11;:13::i;:::-;68456:30;;67304:4;68505:13;:11;:13::i;:::-;:25;68501:98;;;68551:32;68561:10;68573:9;68551;:32::i;:::-;-1:-1:-1;68436:3:0;;68400:210;;70349:99;65858:12;:10;:12::i;:::-;-1:-1:-1;;;;;65847:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65847:23:0;;65839:68;;;;-1:-1:-1;;;65839:68:0;;;;;;;:::i;:::-;70420:20:::1;70432:7;70420:11;:20::i;:::-;70349:99:::0;:::o;67155:45::-;;;;:::o;51332:177::-;51404:7;51431:70;51448:7;51431:70;;;;;;;;;;;;;;;;;:12;;:70;:16;:70::i;52951:97::-;53032:8;53025:15;;;;;;;;-1:-1:-1;;53025:15:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52999:13;;53025:15;;53032:8;;53025:15;;53032:8;53025:15;;;;;;;;;;;;;;;;;;;;;;;;51049:221;51121:7;-1:-1:-1;;;;;51149:19:0;;51141:74;;;;-1:-1:-1;;;51141:74:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;51233:20:0;;;;;;:13;:20;;;;;:29;;:27;:29::i;66278:148::-;65858:12;:10;:12::i;:::-;-1:-1:-1;;;;;65847:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65847:23:0;;65839:68;;;;-1:-1:-1;;;65839:68:0;;;;;;;:::i;:::-;66369:6:::1;::::0;66348:40:::1;::::0;66385:1:::1;::::0;-1:-1:-1;;;;;66369:6:0::1;::::0;66348:40:::1;::::0;66385:1;;66348:40:::1;66399:6;:19:::0;;-1:-1:-1;;;;;;66399:19:0::1;::::0;;66278:148::o;70456:502::-;70517:16;70547:18;70568:17;70578:6;70568:9;:17::i;:::-;70547:38;-1:-1:-1;70600:15:0;70596:355;;70639:16;;;70653:1;70639:16;;;;;;;;;;;;70596:355;70688:23;70728:10;70714:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;70714:25:0;;70688:51;;70754:13;70782:130;70806:10;70798:5;:18;70782:130;;;70862:34;70882:6;70890:5;70862:19;:34::i;:::-;70846:6;70853:5;70846:13;;;;;;;;;;;;;;;;;:50;70818:7;;70782:130;;65627:87;65700:6;;-1:-1:-1;;;;;65700:6:0;65627:87;:::o;51745:104::-;51834:7;51827:14;;;;;;;;-1:-1:-1;;51827:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51801:13;;51827:14;;51834:7;;51827:14;;51834:7;51827:14;;;;;;;;;;;;;;;;;;;;;;;;67067:31;;;;;;;;;;;;;;;-1:-1:-1;;67067:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67219:42;67259:2;67219:42;:::o;54655:295::-;54770:12;:10;:12::i;:::-;-1:-1:-1;;;;;54758:24:0;:8;-1:-1:-1;;;;;54758:24:0;;;54750:62;;;;-1:-1:-1;;;54750:62:0;;;;;;;:::i;:::-;54870:8;54825:18;:32;54844:12;:10;:12::i;:::-;-1:-1:-1;;;;;54825:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;54825:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;54825:53:0;;;;;;;;;;;54909:12;:10;:12::i;:::-;-1:-1:-1;;;;;54894:48:0;;54933:8;54894:48;;;;;;:::i;:::-;;;;;;;;54655:295;;:::o;69806:401::-;65858:12;:10;:12::i;:::-;-1:-1:-1;;;;;65847:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65847:23:0;;65839:68;;;;-1:-1:-1;;;65839:68:0;;;;;;;:::i;:::-;69901:11:::1;69915:13;:11;:13::i;:::-;69901:27;;69964:1;69947:14;:18;:52;;;;;69987:12;;69969:14;:30;;69947:52;69939:97;;;;-1:-1:-1::0;;;69939:97:0::1;;;;;;;:::i;:::-;70052:6;70047:95;70068:14;70064:1;:18;70047:95;;;70104:26;70114:3;70128:1;70119:6;:10;70104:9;:26::i;:::-;70084:3;;70047:95;;;-1:-1:-1::0;70167:12:0::1;::::0;:32:::1;::::0;70184:14;70167:16:::1;:32::i;:::-;70152:12;:47:::0;-1:-1:-1;;;69806:401:0:o;67008:35::-;;;;;;;;;;;;;;;-1:-1:-1;;67008:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71292:174;65858:12;:10;:12::i;:::-;-1:-1:-1;;;;;65847:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65847:23:0;;65839:68;;;;-1:-1:-1;;;65839:68:0;;;;;;;:::i;:::-;71375:13:::1;::::0;::::1;;:22;71367:57;;;;-1:-1:-1::0;;;71367:57:0::1;;;;;;;:::i;:::-;71435:23:::0;;::::1;::::0;:12:::1;::::0;:23:::1;::::0;::::1;::::0;::::1;:::i;55850:285::-:0;55982:41;56001:12;:10;:12::i;:::-;56015:7;55982:18;:41::i;:::-;55974:103;;;;-1:-1:-1;;;55974:103:0;;;;;;;:::i;:::-;56088:39;56102:4;56108:2;56112:7;56121:5;56088:13;:39::i;:::-;55850:285;;;;:::o;71155:125::-;65858:12;:10;:12::i;:::-;-1:-1:-1;;;;;65847:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65847:23:0;;65839:68;;;;-1:-1:-1;;;65839:68:0;;;;;;;:::i;:::-;71206:13:::1;:21:::0;;-1:-1:-1;;71206:21:0::1;71223:4;71206:21;::::0;;71243:29:::1;::::0;::::1;::::0;::::1;::::0;71259:12:::1;::::0;71243:29:::1;:::i;:::-;;;;;;;;71155:125::o:0;67268:40::-;67304:4;67268:40;:::o;67840:91::-;65858:12;:10;:12::i;:::-;-1:-1:-1;;;;;65847:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65847:23:0;;65839:68;;;;-1:-1:-1;;;65839:68:0;;;;;;;:::i;:::-;67902:10:::1;:21:::0;67840:91::o;67402:30::-;;;;:::o;51920:792::-;51993:13;52027:16;52035:7;52027;:16::i;:::-;52019:76;;;;-1:-1:-1;;;52019:76:0;;;;;;;:::i;:::-;52108:23;52134:19;;;:10;:19;;;;;;;;52108:45;;;;;;;;;;;-1:-1:-1;;52108:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;52134:19;;52108:45;;;52134:19;52108:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52164:18;52185:9;:7;:9::i;:::-;52164:30;;52276:4;52270:18;52292:1;52270:23;52266:72;;;-1:-1:-1;52317:9:0;-1:-1:-1;52310:16:0;;52266:72;52442:23;;:27;52438:108;;52517:4;52523:9;52500:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;52486:48;;;;;;52438:108;52678:4;52684:18;:7;:16;:18::i;:::-;52661:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;52647:57;;;;51920:792;;;:::o;70970:173::-;71022:13;71062;:11;:13::i;:::-;71056:3;:19;71048:57;;;;-1:-1:-1;;;71048:57:0;;;;;;;:::i;:::-;71123:12;71116:19;;;;;;;;;;;;;-1:-1:-1;;71116:19:0;;;;;;;;;;;;;;;;;;;;;;;;;;;71123:12;71116:19;;71123:12;71116:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70970:173;;;:::o;55021:164::-;-1:-1:-1;;;;;55142:25:0;;;55118:4;55142:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;55021:164::o;67315:32::-;;;;;;:::o;69030:197::-;69089:13;69135;:11;:13::i;:::-;69124:8;:24;69115:66;;;;-1:-1:-1;;;69115:66:0;;;;;;;:::i;:::-;69199:20;;;;:10;:20;;;;;;;;;69192:27;;;;;;-1:-1:-1;;69192:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69199:20;;69192:27;;69199:20;69192:27;;;;;;;;;;;;;;;;;;;;;;;;66581:244;65858:12;:10;:12::i;:::-;-1:-1:-1;;;;;65847:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65847:23:0;;65839:68;;;;-1:-1:-1;;;65839:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;66670:22:0;::::1;66662:73;;;;-1:-1:-1::0;;;66662:73:0::1;;;;;;;:::i;:::-;66772:6;::::0;66751:38:::1;::::0;-1:-1:-1;;;;;66751:38:0;;::::1;::::0;66772:6:::1;::::0;66751:38:::1;::::0;66772:6:::1;::::0;66751:38:::1;66800:6;:17:::0;;-1:-1:-1;;;;;;66800:17:0::1;-1:-1:-1::0;;;;;66800:17:0;;;::::1;::::0;;;::::1;::::0;;66581:244::o;57602:127::-;57667:4;57691:30;:12;57713:7;57691:21;:30::i;739:106::-;827:10;739:106;:::o;63620:192::-;63695:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;63695:29:0;-1:-1:-1;;;;;63695:29:0;;;;;;;;:24;;63749:23;63695:24;63749:14;:23::i;:::-;-1:-1:-1;;;;;63740:46:0;;;;;;;;;;;63620:192;;:::o;44341:123::-;44410:7;44437:19;44445:3;44437:7;:19::i;57896:355::-;57989:4;58014:16;58022:7;58014;:16::i;:::-;58006:73;;;;-1:-1:-1;;;58006:73:0;;;;;;;:::i;:::-;58090:13;58106:23;58121:7;58106:14;:23::i;:::-;58090:39;;58159:5;-1:-1:-1;;;;;58148:16:0;:7;-1:-1:-1;;;;;58148:16:0;;:51;;;;58192:7;-1:-1:-1;;;;;58168:31:0;:20;58180:7;58168:11;:20::i;:::-;-1:-1:-1;;;;;58168:31:0;;58148:51;:94;;;;58203:39;58227:5;58234:7;58203:23;:39::i;:::-;58140:103;57896:355;-1:-1:-1;;;;57896:355:0:o;61032:599::-;61157:4;-1:-1:-1;;;;;61130:31:0;:23;61145:7;61130:14;:23::i;:::-;-1:-1:-1;;;;;61130:31:0;;61122:85;;;;-1:-1:-1;;;61122:85:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;61244:16:0;;61236:65;;;;-1:-1:-1;;;61236:65:0;;;;;;;:::i;:::-;61314:39;61335:4;61341:2;61345:7;61314:20;:39::i;:::-;61418:29;61435:1;61439:7;61418:8;:29::i;:::-;-1:-1:-1;;;;;61460:19:0;;;;;;:13;:19;;;;;:35;;61487:7;61460:26;:35::i;:::-;-1:-1:-1;;;;;;61506:17:0;;;;;;:13;:17;;;;;:30;;61528:7;61506:21;:30::i;:::-;-1:-1:-1;61549:29:0;:12;61566:7;61575:2;61549:16;:29::i;:::-;;61615:7;61611:2;-1:-1:-1;;;;;61596:27:0;61605:4;-1:-1:-1;;;;;61596:27:0;;;;;;;;;;;61032:599;;;:::o;36132:137::-;36203:7;36238:22;36242:3;36254:5;36238:3;:22::i;44803:236::-;44883:7;;;;44943:22;44947:3;44959:5;44943:3;:22::i;:::-;44912:53;;;;-1:-1:-1;44803:236:0;-1:-1:-1;;;;;44803:236:0:o;13860:179::-;13918:7;13950:5;;;13974:6;;;;13966:46;;;;-1:-1:-1;;;13966:46:0;;;;;;;:::i;14739:220::-;14797:7;14821:6;14817:20;;-1:-1:-1;14836:1:0;14829:8;;14817:20;14860:5;;;14864:1;14860;:5;:1;14884:5;;;;;:10;14876:56;;;;-1:-1:-1;;;14876:56:0;;;;;;;:::i;58594:110::-;58670:26;58680:2;58684:7;58670:26;;;;;;;;;;;;:9;:26::i;62232:100::-;62305:19;;;;:8;;:19;;;;;:::i;46089:213::-;46196:7;46247:44;46252:3;46272;46278:12;46247:4;:44::i;:::-;46239:53;-1:-1:-1;46089:213:0;;;;;;:::o;14322:158::-;14380:7;14413:1;14408;:6;;14400:49;;;;-1:-1:-1;;;14400:49:0;;;;;;;:::i;:::-;-1:-1:-1;14467:5:0;;;14322:158::o;57017:272::-;57131:28;57141:4;57147:2;57151:7;57131:9;:28::i;:::-;57178:48;57201:4;57207:2;57211:7;57220:5;57178:22;:48::i;:::-;57170:111;;;;-1:-1:-1;;;57170:111:0;;;;;;;:::i;46553:746::-;46609:13;46830:10;46826:53;;-1:-1:-1;46857:10:0;;;;;;;;;;;;-1:-1:-1;;;46857:10:0;;;;;;46826:53;46904:5;46889:12;46945:78;46952:9;;46945:78;;46978:8;;47009:2;47001:10;;;;46945:78;;;47033:19;47065:6;47055:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;47055:17:0;-1:-1:-1;47127:5:0;;-1:-1:-1;47033:39:0;-1:-1:-1;;;47099:10:0;;47143:117;47150:9;;47143:117;;47219:2;47212:4;:9;47207:2;:14;47194:29;;47176:6;47183:7;;;;;;;47176:15;;;;;;;;;;;:47;-1:-1:-1;;;;;47176:47:0;;;;;;;;-1:-1:-1;47246:2:0;47238:10;;;;47143:117;;;-1:-1:-1;47284:6:0;46553:746;-1:-1:-1;;;;46553:746:0:o;44102:151::-;44186:4;44210:35;44220:3;44240;44210:9;:35::i;40920:110::-;41003:19;;40920:110::o;35219:137::-;35289:4;35313:35;35321:3;35341:5;35313:7;:35::i;34912:131::-;34979:4;35003:32;35008:3;35028:5;35003:4;:32::i;43525:185::-;43614:4;43638:64;43643:3;43663;-1:-1:-1;;;;;43677:23:0;;43638:4;:64::i;31170:204::-;31265:18;;31237:7;;31265:26;-1:-1:-1;31257:73:0;;;;-1:-1:-1;;;31257:73:0;;;;;;;:::i;:::-;31348:3;:11;;31360:5;31348:18;;;;;;;;;;;;;;;;31341:25;;31170:204;;;;:::o;41385:279::-;41489:19;;41452:7;;;;41489:27;-1:-1:-1;41481:74:0;;;;-1:-1:-1;;;41481:74:0;;;;;;;:::i;:::-;41568:22;41593:3;:12;;41606:5;41593:19;;;;;;;;;;;;;;;;;;41568:44;;41631:5;:10;;;41643:5;:12;;;41623:33;;;;;41385:279;;;;;:::o;58931:250::-;59027:18;59033:2;59037:7;59027:5;:18::i;:::-;59064:54;59095:1;59099:2;59103:7;59112:5;59064:22;:54::i;:::-;59056:117;;;;-1:-1:-1;;;59056:117:0;;;;;;;:::i;42882:319::-;42976:7;43015:17;;;:12;;;:17;;;;;;43066:12;43051:13;43043:36;;;;-1:-1:-1;;;43043:36:0;;;;;;;;:::i;:::-;;43133:3;:12;;43157:1;43146:8;:12;43133:26;;;;;;;;;;;;;;;;;;:33;;;43126:40;;;42882:319;;;;;:::o;62897:604::-;63018:4;63045:15;:2;-1:-1:-1;;;;;63045:13:0;;:15::i;:::-;63040:60;;-1:-1:-1;63084:4:0;63077:11;;63040:60;63110:23;63136:252;-1:-1:-1;;;63249:12:0;:10;:12::i;:::-;63276:4;63295:7;63317:5;63152:181;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;63152:181:0;;;;;;;-1:-1:-1;;;;;63152:181:0;;;;;;;;;;;63136:252;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;63136:15:0;;;:252;:15;:252::i;:::-;63110:278;;63399:13;63426:10;63415:32;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;63466:26:0;-1:-1:-1;;;63466:26:0;;-1:-1:-1;;;62897:604:0;;;;;;:::o;40700:125::-;40771:4;40795:17;;;:12;;;;;:17;;;;;;:22;;;40700:125::o;28872:1544::-;28938:4;29077:19;;;:12;;;:19;;;;;;29113:15;;29109:1300;;29548:18;;-1:-1:-1;;29499:14:0;;;;29548:22;;;;29475:21;;29548:3;;:22;;29835;;;;;;;;;;;;;;29815:42;;29981:9;29952:3;:11;;29964:13;29952:26;;;;;;;;;;;;;;;;;;;:38;;;;30058:23;;;30100:1;30058:12;;;:23;;;;;;30084:17;;;30058:43;;30210:17;;30058:3;;30210:17;;;;;;;;;;;;;;;;;;;;;;30305:3;:12;;:19;30318:5;30305:19;;;;;;;;;;;30298:26;;;30348:4;30341:11;;;;;;;;29109:1300;30392:5;30385:12;;;;;28282:414;28345:4;28367:21;28377:3;28382:5;28367:9;:21::i;:::-;28362:327;;-1:-1:-1;28405:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;28588:18;;28566:19;;;:12;;;:19;;;;;;:40;;;;28621:11;;28362:327;-1:-1:-1;28672:5:0;28665:12;;38200:692;38276:4;38411:17;;;:12;;;:17;;;;;;38445:13;38441:444;;-1:-1:-1;;38530:38:0;;;;;;;;;;;;;;;;;;38512:57;;;;;;;;:12;:57;;;;;;;;;;;;;;;;;;;;;;;;38727:19;;38707:17;;;:12;;;:17;;;;;;;:39;38761:11;;38441:444;38841:5;38805:3;:12;;38829:1;38818:8;:12;38805:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;38868:5;38861:12;;;;;59517:404;-1:-1:-1;;;;;59597:16:0;;59589:61;;;;-1:-1:-1;;;59589:61:0;;;;;;;:::i;:::-;59670:16;59678:7;59670;:16::i;:::-;59669:17;59661:58;;;;-1:-1:-1;;;59661:58:0;;;;;;;:::i;:::-;59732:45;59761:1;59765:2;59769:7;59732:20;:45::i;:::-;-1:-1:-1;;;;;59790:17:0;;;;;;:13;:17;;;;;:30;;59812:7;59790:21;:30::i;:::-;-1:-1:-1;59833:29:0;:12;59850:7;59859:2;59833:16;:29::i;:::-;-1:-1:-1;59880:33:0;;59905:7;;-1:-1:-1;;;;;59880:33:0;;;59897:1;;59880:33;;59897:1;;59880:33;59517:404;;:::o;19301:422::-;19668:20;19707:8;;;19301:422::o;22219:195::-;22322:12;22354:52;22376:6;22384:4;22390:1;22393:12;22322;23523:18;23534:6;23523:10;:18::i;:::-;23515:60;;;;-1:-1:-1;;;23515:60:0;;;;;;;:::i;:::-;23649:12;23663:23;23690:6;-1:-1:-1;;;;;23690:11:0;23710:5;23718:4;23690:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23648:75;;;;23741:52;23759:7;23768:10;23780:12;23741:17;:52::i;:::-;23734:59;23271:530;-1:-1:-1;;;;;;;23271:530:0:o;25811:742::-;25926:12;25955:7;25951:595;;;-1:-1:-1;25986:10:0;25979:17;;25951:595;26100:17;;:21;26096:439;;26363:10;26357:17;26424:15;26411:10;26407:2;26403:19;26396:44;26311:148;26506:12;26499:20;;-1:-1:-1;;;26499:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:589:1;;110:18;151:2;143:6;140:14;137:2;;;157:9;137:2;197;191:9;270:2;247:17;;-1:-1:-1;;243:31:1;231:44;;277:4;227:55;297:18;;;317:22;;;294:46;291:2;;;343:9;291:2;370;363:22;418;;;403:6;-1:-1:-1;403:6:1;455:16;;;452:25;-1:-1:-1;449:2:1;;;490:1;487;480:12;449:2;540:6;535:3;528:4;520:6;516:17;503:44;595:1;588:4;579:6;571;567:19;563:30;556:41;;;90:513;;;;;:::o;608:175::-;678:20;;-1:-1:-1;;;;;727:31:1;;717:42;;707:2;;773:1;770;763:12;788:233;;886:3;879:4;871:6;867:17;863:27;853:2;;908:5;901;894:20;853:2;934:81;1011:3;1002:6;989:20;982:4;974:6;970:17;934:81;:::i;1026:198::-;;1138:2;1126:9;1117:7;1113:23;1109:32;1106:2;;;1159:6;1151;1144:22;1106:2;1187:31;1208:9;1187:31;:::i;1229:274::-;;;1358:2;1346:9;1337:7;1333:23;1329:32;1326:2;;;1379:6;1371;1364:22;1326:2;1407:31;1428:9;1407:31;:::i;:::-;1397:41;;1457:40;1493:2;1482:9;1478:18;1457:40;:::i;:::-;1447:50;;1316:187;;;;;:::o;1508:342::-;;;;1654:2;1642:9;1633:7;1629:23;1625:32;1622:2;;;1675:6;1667;1660:22;1622:2;1703:31;1724:9;1703:31;:::i;:::-;1693:41;;1753:40;1789:2;1778:9;1774:18;1753:40;:::i;:::-;1743:50;;1840:2;1829:9;1825:18;1812:32;1802:42;;1612:238;;;;;:::o;1855:702::-;;;;;2027:3;2015:9;2006:7;2002:23;1998:33;1995:2;;;2049:6;2041;2034:22;1995:2;2077:31;2098:9;2077:31;:::i;:::-;2067:41;;2127:40;2163:2;2152:9;2148:18;2127:40;:::i;:::-;2117:50;;2214:2;2203:9;2199:18;2186:32;2176:42;;2269:2;2258:9;2254:18;2241:32;2296:18;2288:6;2285:30;2282:2;;;2333:6;2325;2318:22;2282:2;2361:22;;2414:4;2406:13;;2402:27;-1:-1:-1;2392:2:1;;2448:6;2440;2433:22;2392:2;2476:75;2543:7;2538:2;2525:16;2520:2;2516;2512:11;2476:75;:::i;:::-;2466:85;;;1985:572;;;;;;;:::o;2562:369::-;;;2688:2;2676:9;2667:7;2663:23;2659:32;2656:2;;;2709:6;2701;2694:22;2656:2;2737:31;2758:9;2737:31;:::i;:::-;2727:41;;2818:2;2807:9;2803:18;2790:32;2865:5;2858:13;2851:21;2844:5;2841:32;2831:2;;2892:6;2884;2877:22;2831:2;2920:5;2910:15;;;2646:285;;;;;:::o;2936:266::-;;;3065:2;3053:9;3044:7;3040:23;3036:32;3033:2;;;3086:6;3078;3071:22;3033:2;3114:31;3135:9;3114:31;:::i;:::-;3104:41;3192:2;3177:18;;;;3164:32;;-1:-1:-1;;;3023:179:1:o;3207:194::-;;3330:2;3318:9;3309:7;3305:23;3301:32;3298:2;;;3351:6;3343;3336:22;3298:2;-1:-1:-1;3379:16:1;;3288:113;-1:-1:-1;3288:113:1:o;3406:257::-;;3517:2;3505:9;3496:7;3492:23;3488:32;3485:2;;;3538:6;3530;3523:22;3485:2;3582:9;3569:23;3601:32;3627:5;3601:32;:::i;3668:261::-;;3790:2;3778:9;3769:7;3765:23;3761:32;3758:2;;;3811:6;3803;3796:22;3758:2;3848:9;3842:16;3867:32;3893:5;3867:32;:::i;3934:344::-;;4056:2;4044:9;4035:7;4031:23;4027:32;4024:2;;;4077:6;4069;4062:22;4024:2;4122:9;4109:23;4155:18;4147:6;4144:30;4141:2;;;4192:6;4184;4177:22;4141:2;4220:52;4264:7;4255:6;4244:9;4240:22;4220:52;:::i;4283:190::-;;4395:2;4383:9;4374:7;4370:23;4366:32;4363:2;;;4416:6;4408;4401:22;4363:2;-1:-1:-1;4444:23:1;;4353:120;-1:-1:-1;4353:120:1:o;4478:412::-;;;4617:2;4605:9;4596:7;4592:23;4588:32;4585:2;;;4638:6;4630;4623:22;4585:2;4679:9;4666:23;4656:33;;4740:2;4729:9;4725:18;4712:32;4767:18;4759:6;4756:30;4753:2;;;4804:6;4796;4789:22;4753:2;4832:52;4876:7;4867:6;4856:9;4852:22;4832:52;:::i;:::-;4822:62;;;4575:315;;;;;:::o;4895:259::-;;4976:5;4970:12;5003:6;4998:3;4991:19;5019:63;5075:6;5068:4;5063:3;5059:14;5052:4;5045:5;5041:16;5019:63;:::i;:::-;5136:2;5115:15;-1:-1:-1;;5111:29:1;5102:39;;;;5143:4;5098:50;;4946:208;-1:-1:-1;;4946:208:1:o;5159:274::-;;5326:6;5320:13;5342:53;5388:6;5383:3;5376:4;5368:6;5364:17;5342:53;:::i;:::-;5411:16;;;;;5296:137;-1:-1:-1;;5296:137:1:o;5438:830::-;;5597:3;5632:6;5626:13;5658:1;5690:2;5679:9;5675:18;5707:1;5702:126;;;;5842:1;5837:406;;;;5668:575;;5702:126;-1:-1:-1;;5735:24:1;;5723:37;;5808:1;5793:17;;5812:4;5789:28;5780:38;;;-1:-1:-1;5702:126:1;;5837:406;5887:1;5876:9;5872:17;5914:6;5909:3;5902:19;5944:4;5991:2;5986:3;5976:18;6016:3;6032:165;6046:6;6043:1;6040:13;6032:165;;;6124:14;;6111:11;;;6104:35;6167:16;;;;6061:10;;6032:165;;;-1:-1:-1;;;6217:16:1;;;-1:-1:-1;5668:575:1;-1:-1:-1;6259:3:1;;5576:692;-1:-1:-1;;;;;5576:692:1:o;6273:470::-;;6490:6;6484:13;6506:53;6552:6;6547:3;6540:4;6532:6;6528:17;6506:53;:::i;:::-;6622:13;;6581:16;;;;6644:57;6622:13;6581:16;6678:4;6666:17;;6644:57;:::i;:::-;6717:20;;6460:283;-1:-1:-1;;;;6460:283:1:o;6748:203::-;-1:-1:-1;;;;;6912:32:1;;;;6894:51;;6882:2;6867:18;;6849:102::o;6956:506::-;-1:-1:-1;;;;;7241:15:1;;;7223:34;;7293:15;;7288:2;7273:18;;7266:43;7340:2;7325:18;;7318:34;;;7388:3;7383:2;7368:18;;7361:31;;;6956:506;;7409:47;;7436:19;;7428:6;7409:47;:::i;:::-;7401:55;7175:287;-1:-1:-1;;;;;;7175:287:1:o;7467:397::-;;7709:1;7705;7700:3;7696:11;7692:19;7684:6;7680:32;7669:9;7662:51;7749:6;7744:2;7733:9;7729:18;7722:34;7792:2;7787;7776:9;7772:18;7765:30;7812:46;7854:2;7843:9;7839:18;7831:6;7812:46;:::i;:::-;7804:54;7652:212;-1:-1:-1;;;;;7652:212:1:o;7869:808::-;;8060:2;8100;8089:9;8085:18;8130:2;8119:9;8112:21;8153:6;8188;8182:13;8219:6;8211;8204:22;8257:2;8246:9;8242:18;8235:25;;8320:2;8314;8306:6;8302:15;8291:9;8287:31;8283:40;8269:54;;8358:2;8350:6;8346:15;8379:4;8392:256;8406:6;8403:1;8400:13;8392:256;;;8499:2;8495:7;8483:9;8475:6;8471:22;8467:36;8462:3;8455:49;8527:41;8561:6;8552;8546:13;8527:41;:::i;:::-;8517:51;-1:-1:-1;8626:12:1;;;;8591:15;;;;8428:1;8421:9;8392:256;;;-1:-1:-1;8665:6:1;;8040:637;-1:-1:-1;;;;;;;8040:637:1:o;8682:635::-;8853:2;8905:21;;;8975:13;;8878:18;;;8997:22;;;8682:635;;8853:2;9076:15;;;;9050:2;9035:18;;;8682:635;9122:169;9136:6;9133:1;9130:13;9122:169;;;9197:13;;9185:26;;9266:15;;;;9231:12;;;;9158:1;9151:9;9122:169;;;-1:-1:-1;9308:3:1;;8833:484;-1:-1:-1;;;;;;8833:484:1:o;9322:187::-;9487:14;;9480:22;9462:41;;9450:2;9435:18;;9417:92::o;9514:221::-;;9663:2;9652:9;9645:21;9683:46;9725:2;9714:9;9710:18;9702:6;9683:46;:::i;9740:982::-;;9878:2;9918;9907:9;9903:18;9948:2;9937:9;9930:21;9971:4;10007:6;10001:13;10033:1;10065:2;10054:9;10050:18;10082:1;10077:178;;;;10269:1;10264:432;;;;10043:653;;10077:178;10132:1;10117:17;;10136:4;10113:28;10098:44;;-1:-1:-1;;10182:24:1;;10177:2;10162:18;;10155:52;10242:2;10227:18;;;-1:-1:-1;10077:178:1;;10264:432;10314:1;10303:9;10299:17;10344:6;10336;10329:22;10379:42;10414:6;10379:42;:::i;:::-;10443:4;10460:180;10474:6;10471:1;10468:13;10460:180;;;10567:14;;10543:17;;;10562:2;10539:26;10532:50;10610:16;;;;10489:10;;10460:180;;;10664:17;;10683:2;10660:26;;-1:-1:-1;;;10043:653:1;-1:-1:-1;10713:3:1;;9858:864;-1:-1:-1;;;;;;;9858:864:1:o;10727:398::-;10929:2;10911:21;;;10968:2;10948:18;;;10941:30;11007:34;11002:2;10987:18;;10980:62;-1:-1:-1;;;11073:2:1;11058:18;;11051:32;11115:3;11100:19;;10901:224::o;11130:414::-;11332:2;11314:21;;;11371:2;11351:18;;;11344:30;11410:34;11405:2;11390:18;;11383:62;-1:-1:-1;;;11476:2:1;11461:18;;11454:48;11534:3;11519:19;;11304:240::o;11549:402::-;11751:2;11733:21;;;11790:2;11770:18;;;11763:30;11829:34;11824:2;11809:18;;11802:62;-1:-1:-1;;;11895:2:1;11880:18;;11873:36;11941:3;11926:19;;11723:228::o;11956:352::-;12158:2;12140:21;;;12197:2;12177:18;;;12170:30;12236;12231:2;12216:18;;12209:58;12299:2;12284:18;;12130:178::o;12313:351::-;12515:2;12497:21;;;12554:2;12534:18;;;12527:30;12593:29;12588:2;12573:18;;12566:57;12655:2;12640:18;;12487:177::o;12669:349::-;12871:2;12853:21;;;12910:2;12890:18;;;12883:30;12949:27;12944:2;12929:18;;12922:55;13009:2;12994:18;;12843:175::o;13023:356::-;13225:2;13207:21;;;13244:18;;;13237:30;13303:34;13298:2;13283:18;;13276:62;13370:2;13355:18;;13197:182::o;13384:400::-;13586:2;13568:21;;;13625:2;13605:18;;;13598:30;13664:34;13659:2;13644:18;;13637:62;-1:-1:-1;;;13730:2:1;13715:18;;13708:34;13774:3;13759:19;;13558:226::o;13789:349::-;13991:2;13973:21;;;14030:2;14010:18;;;14003:30;14069:27;14064:2;14049:18;;14042:55;14129:2;14114:18;;13963:175::o;14143:355::-;14345:2;14327:21;;;14384:2;14364:18;;;14357:30;14423:33;14418:2;14403:18;;14396:61;14489:2;14474:18;;14317:181::o;14503:354::-;14705:2;14687:21;;;14744:2;14724:18;;;14717:30;14783:32;14778:2;14763:18;;14756:60;14848:2;14833:18;;14677:180::o;15269:408::-;15471:2;15453:21;;;15510:2;15490:18;;;15483:30;15549:34;15544:2;15529:18;;15522:62;-1:-1:-1;;;15615:2:1;15600:18;;15593:42;15667:3;15652:19;;15443:234::o;15682:397::-;15884:2;15866:21;;;15923:2;15903:18;;;15896:30;15962:34;15957:2;15942:18;;15935:62;-1:-1:-1;;;16028:2:1;16013:18;;16006:31;16069:3;16054:19;;15856:223::o;16084:420::-;16286:2;16268:21;;;16325:2;16305:18;;;16298:30;16364:34;16359:2;16344:18;;16337:62;16435:26;16430:2;16415:18;;16408:54;16494:3;16479:19;;16258:246::o;16509:406::-;16711:2;16693:21;;;16750:2;16730:18;;;16723:30;16789:34;16784:2;16769:18;;16762:62;-1:-1:-1;;;16855:2:1;16840:18;;16833:40;16905:3;16890:19;;16683:232::o;16920:404::-;17122:2;17104:21;;;17161:2;17141:18;;;17134:30;17200:34;17195:2;17180:18;;17173:62;-1:-1:-1;;;17266:2:1;17251:18;;17244:38;17314:3;17299:19;;17094:230::o;17329:398::-;17531:2;17513:21;;;17570:2;17550:18;;;17543:30;17609:34;17604:2;17589:18;;17582:62;-1:-1:-1;;;17675:2:1;17660:18;;17653:32;17717:3;17702:19;;17503:224::o;17732:356::-;17934:2;17916:21;;;17953:18;;;17946:30;18012:34;18007:2;17992:18;;17985:62;18079:2;18064:18;;17906:182::o;18093:397::-;18295:2;18277:21;;;18334:2;18314:18;;;18307:30;18373:34;18368:2;18353:18;;18346:62;-1:-1:-1;;;18439:2:1;18424:18;;18417:31;18480:3;18465:19;;18267:223::o;18495:408::-;18697:2;18679:21;;;18736:2;18716:18;;;18709:30;18775:34;18770:2;18755:18;;18748:62;-1:-1:-1;;;18841:2:1;18826:18;;18819:42;18893:3;18878:19;;18669:234::o;18908:356::-;19110:2;19092:21;;;19129:18;;;19122:30;19188:34;19183:2;19168:18;;19161:62;19255:2;19240:18;;19082:182::o;19269:405::-;19471:2;19453:21;;;19510:2;19490:18;;;19483:30;19549:34;19544:2;19529:18;;19522:62;-1:-1:-1;;;19615:2:1;19600:18;;19593:39;19664:3;19649:19;;19443:231::o;19679:411::-;19881:2;19863:21;;;19920:2;19900:18;;;19893:30;19959:34;19954:2;19939:18;;19932:62;-1:-1:-1;;;20025:2:1;20010:18;;20003:45;20080:3;20065:19;;19853:237::o;20095:399::-;20297:2;20279:21;;;20336:2;20316:18;;;20309:30;20375:34;20370:2;20355:18;;20348:62;-1:-1:-1;;;20441:2:1;20426:18;;20419:33;20484:3;20469:19;;20269:225::o;20499:397::-;20701:2;20683:21;;;20740:2;20720:18;;;20713:30;20779:34;20774:2;20759:18;;20752:62;-1:-1:-1;;;20845:2:1;20830:18;;20823:31;20886:3;20871:19;;20673:223::o;20901:397::-;21103:2;21085:21;;;21142:2;21122:18;;;21115:30;21181:34;21176:2;21161:18;;21154:62;-1:-1:-1;;;21247:2:1;21232:18;;21225:31;21288:3;21273:19;;21075:223::o;21303:351::-;21505:2;21487:21;;;21544:2;21524:18;;;21517:30;21583:29;21578:2;21563:18;;21556:57;21645:2;21630:18;;21477:177::o;21659:405::-;21861:2;21843:21;;;21900:2;21880:18;;;21873:30;21939:34;21934:2;21919:18;;21912:62;-1:-1:-1;;;22005:2:1;21990:18;;21983:39;22054:3;22039:19;;21833:231::o;22069:346::-;22271:2;22253:21;;;22310:2;22290:18;;;22283:30;-1:-1:-1;;;22344:2:1;22329:18;;22322:52;22406:2;22391:18;;22243:172::o;22420:413::-;22622:2;22604:21;;;22661:2;22641:18;;;22634:30;22700:34;22695:2;22680:18;;22673:62;-1:-1:-1;;;22766:2:1;22751:18;;22744:47;22823:3;22808:19;;22594:239::o;22838:353::-;23040:2;23022:21;;;23079:2;23059:18;;;23052:30;23118:31;23113:2;23098:18;;23091:59;23182:2;23167:18;;23012:179::o;23196:177::-;23342:25;;;23330:2;23315:18;;23297:76::o;23378:132::-;;23449:17;;;23499:4;23483:21;;;23439:71::o;23515:258::-;23587:1;23597:113;23611:6;23608:1;23605:13;23597:113;;;23687:11;;;23681:18;23668:11;;;23661:39;23633:2;23626:10;23597:113;;;23728:6;23725:1;23722:13;23719:2;;;-1:-1:-1;;23763:1:1;23745:16;;23738:27;23568:205::o;23778:133::-;-1:-1:-1;;;;;;23854:32:1;;23844:43;;23834:2;;23901:1;23898;23891:12

Swarm Source

ipfs://f9b20cd5edf001760ef01f8cec4eb785b7e902e60503dc7198f6552b6bbcb443

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