Token

Nightmare Serum (NSER)

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

ERC-721

Overview

Max Total Supply

6,859 NSER

Holders

2,012

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x60a300ca7d089ff3dcf037c2a90f52d54de66872

Filtered by Token Holder

0x820A176b5Ad54c6EB56d9708AD1CCB2137CD5484

Balance

1 NSER

0x820a176b5ad54c6eb56d9708ad1ccb2137cd5484

OVERVIEW

It is said that after the moth’s metamorphosis, this will call a creature of nightmare to your wallet.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

NightmareSerum

Compiler Version

v0.7.6+commit.7338295f

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-07-15
*/

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

// SPDX-License-Identifier: MIT

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.
 */
 pragma abicoder v2;
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;
    }
}

/**
 * @dev Extends ERC721 Non-Fungible Token Standard basic implementation
   0x20446576656c6f7065642042792053442d4d414c494e474100000000000000
 */

pragma solidity ^0.7.0;

contract NightmareSerum is ERC721, Ownable {
    using SafeMath for uint256;

    uint256 public MAX_COLLECTION;

    /* Mapping of address to boolean to keep record of wallets  */
    mapping(address=>uint256) public airdropDone;
    

    constructor() ERC721("Nightmare Serum", "NSER")  {
        _setBaseURI("https://serum-api.gossamer.world/api/nft/");
        MAX_COLLECTION = 6900;
    }


    function withdraw() public onlyOwner {
        uint balance = address(this).balance;
        msg.sender.transfer(balance);
    }

    /* 
    @dev checks if one wallet has recieved airdrop or not
    @returns uint256
    @params wallet address
     */
    function checkAirdrop(address add) public view returns(uint256){
        return airdropDone[add];
    }

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


    /* 
    @dev mints NFT as an airdrop token
    @params numberOfTokens - total number of NFTs to be airdropped in this call
    @params wallets [] - array of Addresses to receive NFT
    Can be called only by owner
     */
    function airdropMint(uint numberOfTokens, address[] memory wallets) external onlyOwner {
        require(totalSupply().add(numberOfTokens) <= MAX_COLLECTION, "Mint would exceed max supply");
        require(numberOfTokens!=0 && wallets.length == numberOfTokens, "Send correct address array");
        for(uint256 i=0; i<numberOfTokens; i++){
            airdropDone[wallets[i]] +=1 ;
            uint mintIndex = totalSupply().add(1);
            if (totalSupply() < MAX_COLLECTION) {
                _safeMint(wallets[i], mintIndex);
            }
        }
    }


}

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"},{"inputs":[],"name":"MAX_COLLECTION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"airdropDone","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"},{"internalType":"address[]","name":"wallets","type":"address[]"}],"name":"airdropMint","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":"address","name":"add","type":"address"}],"name":"checkAirdrop","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","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":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

66985:1717:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10227:150;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51525:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54311:221;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53841:404;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;67070:29;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68121:574;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53319:211;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55201:305;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53081:162;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67401:131;;;:::i;:::-;;55577:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53607:172;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67780:99;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51281:177;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52900:97;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50998:221;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66250:148;;;:::i;:::-;;65599:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51694:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67667:105;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54604:295;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;67176:44;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55799:285;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51869:792;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54970:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66553:244;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;10227:150;10312:4;10336:20;:33;10357:11;10336:33;;;;;;;;;;;;;;;;;;;;;;;;;;;10329:40;;10227:150;;;:::o;51525:100::-;51579:13;51612:5;51605:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51525:100;:::o;54311:221::-;54387:7;54415:16;54423:7;54415;:16::i;:::-;54407:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;54500:15;:24;54516:7;54500:24;;;;;;;;;;;;;;;;;;;;;54493:31;;54311:221;;;:::o;53841:404::-;53922:13;53938:23;53953:7;53938:14;:23::i;:::-;53922:39;;53986:5;53980:11;;:2;:11;;;;53972:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;54066:5;54050:21;;:12;:10;:12::i;:::-;:21;;;:69;;;;54075:44;54099:5;54106:12;:10;:12::i;:::-;54075:23;:44::i;:::-;54050:69;54042:161;;;;;;;;;;;;:::i;:::-;;;;;;;;;54216:21;54225:2;54229:7;54216:8;:21::i;:::-;53841:404;;;:::o;67070:29::-;;;;:::o;68121:574::-;65830:12;:10;:12::i;:::-;65819:23;;:7;:5;:7::i;:::-;:23;;;65811:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;68264:14:::1;;68227:33;68245:14;68227:13;:11;:13::i;:::-;:17;;:33;;;;:::i;:::-;:51;;68219:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;68346:1;68330:14;:17;;:53;;;;;68369:14;68351:7;:14;:32;68330:53;68322:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;68429:9;68425:263;68444:14;68442:1;:16;68425:263;;;68505:1;68479:11;:23;68491:7;68499:1;68491:10;;;;;;;;;;;;;;68479:23;;;;;;;;;;;;;;;;:27;;;;;;;;;;;68522:14;68539:20;68557:1;68539:13;:11;:13::i;:::-;:17;;:20;;;;:::i;:::-;68522:37;;68594:14;;68578:13;:11;:13::i;:::-;:30;68574:103;;;68629:32;68639:7;68647:1;68639:10;;;;;;;;;;;;;;68651:9;68629;:32::i;:::-;68574:103;68425:263;68460:3;;;;;;;68425:263;;;;68121:574:::0;;:::o;53319:211::-;53380:7;53501:21;:12;:19;:21::i;:::-;53494:28;;53319:211;:::o;55201:305::-;55362:41;55381:12;:10;:12::i;:::-;55395:7;55362:18;:41::i;:::-;55354:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;55470:28;55480:4;55486:2;55490:7;55470:9;:28::i;:::-;55201:305;;;:::o;53081:162::-;53178:7;53205:30;53229:5;53205:13;:20;53219:5;53205:20;;;;;;;;;;;;;;;:23;;:30;;;;:::i;:::-;53198:37;;53081:162;;;;:::o;67401:131::-;65830:12;:10;:12::i;:::-;65819:23;;:7;:5;:7::i;:::-;:23;;;65811:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;67449:12:::1;67464:21;67449:36;;67496:10;:19;;:28;67516:7;67496:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;65890:1;67401:131::o:0;55577:151::-;55681:39;55698:4;55704:2;55708:7;55681:39;;;;;;;;;;;;:16;:39::i;:::-;55577:151;;;:::o;53607:172::-;53682:7;53703:15;53724:22;53740:5;53724:12;:15;;:22;;;;:::i;:::-;53702:44;;;53764:7;53757:14;;;53607:172;;;:::o;67780:99::-;65830:12;:10;:12::i;:::-;65819:23;;:7;:5;:7::i;:::-;:23;;;65811:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;67851:20:::1;67863:7;67851:11;:20::i;:::-;67780:99:::0;:::o;51281:177::-;51353:7;51380:70;51397:7;51380:70;;;;;;;;;;;;;;;;;:12;:16;;:70;;;;;:::i;:::-;51373:77;;51281:177;;;:::o;52900:97::-;52948:13;52981:8;52974:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52900:97;:::o;50998:221::-;51070:7;51115:1;51098:19;;:5;:19;;;;51090:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;51182:29;:13;:20;51196:5;51182:20;;;;;;;;;;;;;;;:27;:29::i;:::-;51175:36;;50998:221;;;:::o;66250:148::-;65830:12;:10;:12::i;:::-;65819:23;;:7;:5;:7::i;:::-;:23;;;65811:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66357:1:::1;66320:40;;66341:6;;;;;;;;;;;66320:40;;;;;;;;;;;;66388:1;66371:6;;:19;;;;;;;;;;;;;;;;;;66250:148::o:0;65599:87::-;65645:7;65672:6;;;;;;;;;;;65665:13;;65599:87;:::o;51694:104::-;51750:13;51783:7;51776:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51694:104;:::o;67667:105::-;67722:7;67748:11;:16;67760:3;67748:16;;;;;;;;;;;;;;;;67741:23;;67667:105;;;:::o;54604:295::-;54719:12;:10;:12::i;:::-;54707:24;;:8;:24;;;;54699:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;54819:8;54774:18;:32;54793:12;:10;:12::i;:::-;54774:32;;;;;;;;;;;;;;;:42;54807:8;54774:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;54872:8;54843:48;;54858:12;:10;:12::i;:::-;54843:48;;;54882:8;54843:48;;;;;;:::i;:::-;;;;;;;;54604:295;;:::o;67176:44::-;;;;;;;;;;;;;;;;;:::o;55799:285::-;55931:41;55950:12;:10;:12::i;:::-;55964:7;55931:18;:41::i;:::-;55923:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;56037:39;56051:4;56057:2;56061:7;56070:5;56037:13;:39::i;:::-;55799:285;;;;:::o;51869:792::-;51942:13;51976:16;51984:7;51976;:16::i;:::-;51968:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;52057:23;52083:10;:19;52094:7;52083:19;;;;;;;;;;;52057:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52113:18;52134:9;:7;:9::i;:::-;52113:30;;52241:1;52225:4;52219:18;:23;52215:72;;;52266:9;52259:16;;;;;;52215:72;52417:1;52397:9;52391:23;:27;52387:108;;;52466:4;52472:9;52449:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;52435:48;;;;;;52387:108;52627:4;52633:18;:7;:16;:18::i;:::-;52610:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;52596:57;;;;51869:792;;;;:::o;54970:164::-;55067:4;55091:18;:25;55110:5;55091:25;;;;;;;;;;;;;;;:35;55117:8;55091:35;;;;;;;;;;;;;;;;;;;;;;;;;55084:42;;54970:164;;;;:::o;66553:244::-;65830:12;:10;:12::i;:::-;65819:23;;:7;:5;:7::i;:::-;:23;;;65811:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66662:1:::1;66642:22;;:8;:22;;;;66634:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;66752:8;66723:38;;66744:6;;;;;;;;;;;66723:38;;;;;;;;;;;;66781:8;66772:6;;:17;;;;;;;;;;;;;;;;;;66553:244:::0;:::o;57551:127::-;57616:4;57640:30;57662:7;57640:12;:21;;:30;;;;:::i;:::-;57633:37;;57551:127;;;:::o;667:106::-;720:15;755:10;748:17;;667:106;:::o;63569:192::-;63671:2;63644:15;:24;63660:7;63644:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;63727:7;63723:2;63689:46;;63698:23;63713:7;63698:14;:23::i;:::-;63689:46;;;;;;;;;;;;63569:192;;:::o;13789:179::-;13847:7;13867:9;13883:1;13879;:5;13867:17;;13908:1;13903;:6;;13895:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;13959:1;13952:8;;;13789:179;;;;:::o;58543:110::-;58619:26;58629:2;58633:7;58619:26;;;;;;;;;;;;:9;:26::i;:::-;58543:110;;:::o;44270:123::-;44339:7;44366:19;44374:3;:10;;44366:7;:19::i;:::-;44359:26;;44270:123;;;:::o;57845:355::-;57938:4;57963:16;57971:7;57963;:16::i;:::-;57955:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;58039:13;58055:23;58070:7;58055:14;:23::i;:::-;58039:39;;58108:5;58097:16;;:7;:16;;;:51;;;;58141:7;58117:31;;:20;58129:7;58117:11;:20::i;:::-;:31;;;58097:51;:94;;;;58152:39;58176:5;58183:7;58152:23;:39::i;:::-;58097:94;58089:103;;;57845:355;;;;:::o;60981:599::-;61106:4;61079:31;;:23;61094:7;61079:14;:23::i;:::-;:31;;;61071:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;61207:1;61193:16;;:2;:16;;;;61185:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;61263:39;61284:4;61290:2;61294:7;61263:20;:39::i;:::-;61367:29;61384:1;61388:7;61367:8;:29::i;:::-;61409:35;61436:7;61409:13;:19;61423:4;61409:19;;;;;;;;;;;;;;;:26;;:35;;;;:::i;:::-;;61455:30;61477:7;61455:13;:17;61469:2;61455:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;61498:29;61515:7;61524:2;61498:12;:16;;:29;;;;;:::i;:::-;;61564:7;61560:2;61545:27;;61554:4;61545:27;;;;;;;;;;;;60981:599;;;:::o;36061:137::-;36132:7;36167:22;36171:3;:10;;36183:5;36167:3;:22::i;:::-;36159:31;;36152:38;;36061:137;;;;:::o;44732:236::-;44812:7;44821;44842:11;44855:13;44872:22;44876:3;:10;;44888:5;44872:3;:22::i;:::-;44841:53;;;;44921:3;44913:12;;44951:5;44943:14;;44905:55;;;;;;44732:236;;;;;:::o;62181:100::-;62265:8;62254;:19;;;;;;;;;;;;:::i;:::-;;62181:100;:::o;46018:213::-;46125:7;46176:44;46181:3;:10;;46201:3;46193:12;;46207;46176:4;:44::i;:::-;46168:53;;46145:78;;46018:213;;;;;:::o;35603:114::-;35663:7;35690:19;35698:3;:10;;35690:7;:19::i;:::-;35683:26;;35603:114;;;:::o;56966:272::-;57080:28;57090:4;57096:2;57100:7;57080:9;:28::i;:::-;57127:48;57150:4;57156:2;57160:7;57169:5;57127:22;:48::i;:::-;57119:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;56966:272;;;;:::o;46482:746::-;46538:13;46768:1;46759:5;:10;46755:53;;;46786:10;;;;;;;;;;;;;;;;;;;;;46755:53;46818:12;46833:5;46818:20;;46849:14;46874:78;46889:1;46881:4;:9;46874:78;;46907:8;;;;;;;46938:2;46930:10;;;;;;;;;46874:78;;;46962:19;46994:6;46984:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46962:39;;47012:13;47037:1;47028:6;:10;47012:26;;47056:5;47049:12;;47072:117;47087:1;47079:4;:9;47072:117;;47148:2;47141:4;:9;;;;;;47136:2;:14;47123:29;;47105:6;47112:7;;;;;;;47105:15;;;;;;;;;;;:47;;;;;;;;;;;47175:2;47167:10;;;;;;;;;47072:117;;;47213:6;47199:21;;;;;;46482:746;;;;:::o;44031:151::-;44115:4;44139:35;44149:3;:10;;44169:3;44161:12;;44139:9;:35::i;:::-;44132:42;;44031:151;;;;:::o;58880:250::-;58976:18;58982:2;58986:7;58976:5;:18::i;:::-;59013:54;59044:1;59048:2;59052:7;59061:5;59013:22;:54::i;:::-;59005:117;;;;;;;;;;;;:::i;:::-;;;;;;;;;58880:250;;;:::o;40849:110::-;40905:7;40932:3;:12;;:19;;;;40925:26;;40849:110;;;:::o;64374:93::-;;;;:::o;35148:137::-;35218:4;35242:35;35250:3;:10;;35270:5;35262:14;;35242:7;:35::i;:::-;35235:42;;35148:137;;;;:::o;34841:131::-;34908:4;34932:32;34937:3;:10;;34957:5;34949:14;;34932:4;:32::i;:::-;34925:39;;34841:131;;;;:::o;43454:185::-;43543:4;43567:64;43572:3;:10;;43592:3;43584:12;;43622:5;43606:23;;43598:32;;43567:4;:64::i;:::-;43560:71;;43454:185;;;;;:::o;31099:204::-;31166:7;31215:5;31194:3;:11;;:18;;;;:26;31186:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;31277:3;:11;;31289:5;31277:18;;;;;;;;;;;;;;;;31270:25;;31099:204;;;;:::o;41314:279::-;41381:7;41390;41440:5;41418:3;:12;;:19;;;;:27;41410:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;41497:22;41522:3;:12;;41535:5;41522:19;;;;;;;;;;;;;;;;;;41497:44;;41560:5;:10;;;41572:5;:12;;;41552:33;;;;;41314:279;;;;;:::o;42811:319::-;42905:7;42925:16;42944:3;:12;;:17;42957:3;42944:17;;;;;;;;;;;;42925:36;;42992:1;42980:8;:13;;42995:12;42972:36;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;43062:3;:12;;43086:1;43075:8;:12;43062:26;;;;;;;;;;;;;;;;;;:33;;;43055:40;;;42811:319;;;;;:::o;30646:109::-;30702:7;30729:3;:11;;:18;;;;30722:25;;30646:109;;;:::o;62846:604::-;62967:4;62994:15;:2;:13;;;:15::i;:::-;62989:60;;63033:4;63026:11;;;;62989:60;63059:23;63085:252;63138:45;;;63198:12;:10;:12::i;:::-;63225:4;63244:7;63266:5;63101:181;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63085:252;;;;;;;;;;;;;;;;;:2;:15;;;;:252;;;;;:::i;:::-;63059:278;;63348:13;63375:10;63364:32;;;;;;;;;;;;:::i;:::-;63348:48;;48001:10;63425:16;;63415:26;;;:6;:26;;;;63407:35;;;;62846:604;;;;;;;:::o;40629:125::-;40700:4;40745:1;40724:3;:12;;:17;40737:3;40724:17;;;;;;;;;;;;:22;;40717:29;;40629:125;;;;:::o;59466:404::-;59560:1;59546:16;;:2;:16;;;;59538:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;59619:16;59627:7;59619;:16::i;:::-;59618:17;59610:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;59681:45;59710:1;59714:2;59718:7;59681:20;:45::i;:::-;59739:30;59761:7;59739:13;:17;59753:2;59739:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;59782:29;59799:7;59808:2;59782:12;:16;;:29;;;;;:::i;:::-;;59854:7;59850:2;59829:33;;59846:1;59829:33;;;;;;;;;;;;59466:404;;:::o;28801:1544::-;28867:4;28985:18;29006:3;:12;;:19;29019:5;29006:19;;;;;;;;;;;;28985:40;;29056:1;29042:10;:15;29038:1300;;29404:21;29441:1;29428:10;:14;29404:38;;29457:17;29498:1;29477:3;:11;;:18;;;;:22;29457:42;;29744:17;29764:3;:11;;29776:9;29764:22;;;;;;;;;;;;;;;;29744:42;;29910:9;29881:3;:11;;29893:13;29881:26;;;;;;;;;;;;;;;:38;;;;30029:1;30013:13;:17;29987:3;:12;;:23;30000:9;29987:23;;;;;;;;;;;:43;;;;30139:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;30234:3;:12;;:19;30247:5;30234:19;;;;;;;;;;;30227:26;;;30277:4;30270:11;;;;;;;;29038:1300;30321:5;30314:12;;;28801:1544;;;;;:::o;28211:414::-;28274:4;28296:21;28306:3;28311:5;28296:9;:21::i;:::-;28291:327;;28334:3;:11;;28351:5;28334:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28517:3;:11;;:18;;;;28495:3;:12;;:19;28508:5;28495:19;;;;;;;;;;;:40;;;;28557:4;28550:11;;;;28291:327;28601:5;28594:12;;28211:414;;;;;:::o;38129:692::-;38205:4;38321:16;38340:3;:12;;:17;38353:3;38340:17;;;;;;;;;;;;38321:36;;38386:1;38374:8;:13;38370:444;;;38441:3;:12;;38459:38;;;;;;;;38476:3;38459:38;;;;38489:5;38459:38;;;38441:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38656:3;:12;;:19;;;;38636:3;:12;;:17;38649:3;38636:17;;;;;;;;;;;:39;;;;38697:4;38690:11;;;;;38370:444;38770:5;38734:3;:12;;38758:1;38747:8;:12;38734:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;38797:5;38790:12;;;38129:692;;;;;;:::o;19230:422::-;19290:4;19498:12;19609:7;19597:20;19589:28;;19643:1;19636:4;:8;19629:15;;;19230:422;;;:::o;22148:195::-;22251:12;22283:52;22305:6;22313:4;22319:1;22322:12;22283:21;:52::i;:::-;22276:59;;22148:195;;;;;:::o;30431:129::-;30504:4;30551:1;30528:3;:12;;:19;30541:5;30528:19;;;;;;;;;;;;:24;;30521:31;;30431:129;;;;:::o;23200:530::-;23327:12;23385:5;23360:21;:30;;23352:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;23452:18;23463:6;23452:10;:18::i;:::-;23444:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;23578:12;23592:23;23619:6;:11;;23639:5;23647:4;23619:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23577:75;;;;23670:52;23688:7;23697:10;23709:12;23670:17;:52::i;:::-;23663:59;;;;23200:530;;;;;;:::o;25740:742::-;25855:12;25884:7;25880:595;;;25915:10;25908:17;;;;25880:595;26049:1;26029:10;:17;:21;26025:439;;;26292:10;26286:17;26353:15;26340:10;26336:2;26332:19;26325:44;26240:148;26435:12;26428:20;;;;;;;;;;;:::i;:::-;;;;;;;;25740:742;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;24:622:1:-;;145:80;160:64;217:6;160:64;:::i;:::-;145:80;:::i;:::-;136:89;;245:5;273:6;266:5;259:21;299:4;292:5;288:16;281:23;;324:6;374:3;366:4;358:6;354:17;349:3;345:27;342:36;339:2;;;391:1;388;381:12;339:2;419:1;404:236;429:6;426:1;423:13;404:236;;;496:3;524:37;557:3;545:10;524:37;:::i;:::-;519:3;512:50;591:4;586:3;582:14;575:21;;625:4;620:3;616:14;609:21;;464:176;451:1;448;444:9;439:14;;404:236;;;408:14;126:520;;;;;;;:::o;652:342::-;;754:64;769:48;810:6;769:48;:::i;:::-;754:64;:::i;:::-;745:73;;841:6;834:5;827:21;879:4;872:5;868:16;917:3;908:6;903:3;899:16;896:25;893:2;;;934:1;931;924:12;893:2;947:41;981:6;976:3;971;947:41;:::i;:::-;735:259;;;;;;:::o;1000:344::-;;1103:65;1118:49;1160:6;1118:49;:::i;:::-;1103:65;:::i;:::-;1094:74;;1191:6;1184:5;1177:21;1229:4;1222:5;1218:16;1267:3;1258:6;1253:3;1249:16;1246:25;1243:2;;;1284:1;1281;1274:12;1243:2;1297:41;1331:6;1326:3;1321;1297:41;:::i;:::-;1084:260;;;;;;:::o;1350:139::-;;1434:6;1421:20;1412:29;;1450:33;1477:5;1450:33;:::i;:::-;1402:87;;;;:::o;1512:303::-;;1632:3;1625:4;1617:6;1613:17;1609:27;1599:2;;1650:1;1647;1640:12;1599:2;1690:6;1677:20;1715:94;1805:3;1797:6;1790:4;1782:6;1778:17;1715:94;:::i;:::-;1706:103;;1589:226;;;;;:::o;1821:133::-;;1902:6;1889:20;1880:29;;1918:30;1942:5;1918:30;:::i;:::-;1870:84;;;;:::o;1960:137::-;;2043:6;2030:20;2021:29;;2059:32;2085:5;2059:32;:::i;:::-;2011:86;;;;:::o;2103:141::-;;2190:6;2184:13;2175:22;;2206:32;2232:5;2206:32;:::i;:::-;2165:79;;;;:::o;2263:271::-;;2367:3;2360:4;2352:6;2348:17;2344:27;2334:2;;2385:1;2382;2375:12;2334:2;2425:6;2412:20;2450:78;2524:3;2516:6;2509:4;2501:6;2497:17;2450:78;:::i;:::-;2441:87;;2324:210;;;;;:::o;2554:273::-;;2659:3;2652:4;2644:6;2640:17;2636:27;2626:2;;2677:1;2674;2667:12;2626:2;2717:6;2704:20;2742:79;2817:3;2809:6;2802:4;2794:6;2790:17;2742:79;:::i;:::-;2733:88;;2616:211;;;;;:::o;2833:139::-;;2917:6;2904:20;2895:29;;2933:33;2960:5;2933:33;:::i;:::-;2885:87;;;;:::o;2978:262::-;;3086:2;3074:9;3065:7;3061:23;3057:32;3054:2;;;3102:1;3099;3092:12;3054:2;3145:1;3170:53;3215:7;3206:6;3195:9;3191:22;3170:53;:::i;:::-;3160:63;;3116:117;3044:196;;;;:::o;3246:407::-;;;3371:2;3359:9;3350:7;3346:23;3342:32;3339:2;;;3387:1;3384;3377:12;3339:2;3430:1;3455:53;3500:7;3491:6;3480:9;3476:22;3455:53;:::i;:::-;3445:63;;3401:117;3557:2;3583:53;3628:7;3619:6;3608:9;3604:22;3583:53;:::i;:::-;3573:63;;3528:118;3329:324;;;;;:::o;3659:552::-;;;;3801:2;3789:9;3780:7;3776:23;3772:32;3769:2;;;3817:1;3814;3807:12;3769:2;3860:1;3885:53;3930:7;3921:6;3910:9;3906:22;3885:53;:::i;:::-;3875:63;;3831:117;3987:2;4013:53;4058:7;4049:6;4038:9;4034:22;4013:53;:::i;:::-;4003:63;;3958:118;4115:2;4141:53;4186:7;4177:6;4166:9;4162:22;4141:53;:::i;:::-;4131:63;;4086:118;3759:452;;;;;:::o;4217:809::-;;;;;4385:3;4373:9;4364:7;4360:23;4356:33;4353:2;;;4402:1;4399;4392:12;4353:2;4445:1;4470:53;4515:7;4506:6;4495:9;4491:22;4470:53;:::i;:::-;4460:63;;4416:117;4572:2;4598:53;4643:7;4634:6;4623:9;4619:22;4598:53;:::i;:::-;4588:63;;4543:118;4700:2;4726:53;4771:7;4762:6;4751:9;4747:22;4726:53;:::i;:::-;4716:63;;4671:118;4856:2;4845:9;4841:18;4828:32;4887:18;4879:6;4876:30;4873:2;;;4919:1;4916;4909:12;4873:2;4947:62;5001:7;4992:6;4981:9;4977:22;4947:62;:::i;:::-;4937:72;;4799:220;4343:683;;;;;;;:::o;5032:401::-;;;5154:2;5142:9;5133:7;5129:23;5125:32;5122:2;;;5170:1;5167;5160:12;5122:2;5213:1;5238:53;5283:7;5274:6;5263:9;5259:22;5238:53;:::i;:::-;5228:63;;5184:117;5340:2;5366:50;5408:7;5399:6;5388:9;5384:22;5366:50;:::i;:::-;5356:60;;5311:115;5112:321;;;;;:::o;5439:407::-;;;5564:2;5552:9;5543:7;5539:23;5535:32;5532:2;;;5580:1;5577;5570:12;5532:2;5623:1;5648:53;5693:7;5684:6;5673:9;5669:22;5648:53;:::i;:::-;5638:63;;5594:117;5750:2;5776:53;5821:7;5812:6;5801:9;5797:22;5776:53;:::i;:::-;5766:63;;5721:118;5522:324;;;;;:::o;5852:260::-;;5959:2;5947:9;5938:7;5934:23;5930:32;5927:2;;;5975:1;5972;5965:12;5927:2;6018:1;6043:52;6087:7;6078:6;6067:9;6063:22;6043:52;:::i;:::-;6033:62;;5989:116;5917:195;;;;:::o;6118:282::-;;6236:2;6224:9;6215:7;6211:23;6207:32;6204:2;;;6252:1;6249;6242:12;6204:2;6295:1;6320:63;6375:7;6366:6;6355:9;6351:22;6320:63;:::i;:::-;6310:73;;6266:127;6194:206;;;;:::o;6406:375::-;;6524:2;6512:9;6503:7;6499:23;6495:32;6492:2;;;6540:1;6537;6530:12;6492:2;6611:1;6600:9;6596:17;6583:31;6641:18;6633:6;6630:30;6627:2;;;6673:1;6670;6663:12;6627:2;6701:63;6756:7;6747:6;6736:9;6732:22;6701:63;:::i;:::-;6691:73;;6554:220;6482:299;;;;:::o;6787:262::-;;6895:2;6883:9;6874:7;6870:23;6866:32;6863:2;;;6911:1;6908;6901:12;6863:2;6954:1;6979:53;7024:7;7015:6;7004:9;7000:22;6979:53;:::i;:::-;6969:63;;6925:117;6853:196;;;;:::o;7055:550::-;;;7205:2;7193:9;7184:7;7180:23;7176:32;7173:2;;;7221:1;7218;7211:12;7173:2;7264:1;7289:53;7334:7;7325:6;7314:9;7310:22;7289:53;:::i;:::-;7279:63;;7235:117;7419:2;7408:9;7404:18;7391:32;7450:18;7442:6;7439:30;7436:2;;;7482:1;7479;7472:12;7436:2;7510:78;7580:7;7571:6;7560:9;7556:22;7510:78;:::i;:::-;7500:88;;7362:236;7163:442;;;;;:::o;7611:142::-;7714:32;7740:5;7714:32;:::i;:::-;7709:3;7702:45;7692:61;;:::o;7759:118::-;7846:24;7864:5;7846:24;:::i;:::-;7841:3;7834:37;7824:53;;:::o;7883:109::-;7964:21;7979:5;7964:21;:::i;:::-;7959:3;7952:34;7942:50;;:::o;7998:360::-;;8112:38;8144:5;8112:38;:::i;:::-;8166:70;8229:6;8224:3;8166:70;:::i;:::-;8159:77;;8245:52;8290:6;8285:3;8278:4;8271:5;8267:16;8245:52;:::i;:::-;8322:29;8344:6;8322:29;:::i;:::-;8317:3;8313:39;8306:46;;8088:270;;;;;:::o;8364:373::-;;8496:38;8528:5;8496:38;:::i;:::-;8550:88;8631:6;8626:3;8550:88;:::i;:::-;8543:95;;8647:52;8692:6;8687:3;8680:4;8673:5;8669:16;8647:52;:::i;:::-;8724:6;8719:3;8715:16;8708:23;;8472:265;;;;;:::o;8743:364::-;;8859:39;8892:5;8859:39;:::i;:::-;8914:71;8978:6;8973:3;8914:71;:::i;:::-;8907:78;;8994:52;9039:6;9034:3;9027:4;9020:5;9016:16;8994:52;:::i;:::-;9071:29;9093:6;9071:29;:::i;:::-;9066:3;9062:39;9055:46;;8835:272;;;;;:::o;9113:377::-;;9247:39;9280:5;9247:39;:::i;:::-;9302:89;9384:6;9379:3;9302:89;:::i;:::-;9295:96;;9400:52;9445:6;9440:3;9433:4;9426:5;9422:16;9400:52;:::i;:::-;9477:6;9472:3;9468:16;9461:23;;9223:267;;;;;:::o;9496:326::-;;9659:67;9723:2;9718:3;9659:67;:::i;:::-;9652:74;;9756:30;9752:1;9747:3;9743:11;9736:51;9813:2;9808:3;9804:12;9797:19;;9642:180;;;:::o;9828:366::-;;9991:67;10055:2;10050:3;9991:67;:::i;:::-;9984:74;;10088:34;10084:1;10079:3;10075:11;10068:55;10154:4;10149:2;10144:3;10140:12;10133:26;10185:2;10180:3;10176:12;10169:19;;9974:220;;;:::o;10200:382::-;;10363:67;10427:2;10422:3;10363:67;:::i;:::-;10356:74;;10460:34;10456:1;10451:3;10447:11;10440:55;10526:20;10521:2;10516:3;10512:12;10505:42;10573:2;10568:3;10564:12;10557:19;;10346:236;;;:::o;10588:370::-;;10751:67;10815:2;10810:3;10751:67;:::i;:::-;10744:74;;10848:34;10844:1;10839:3;10835:11;10828:55;10914:8;10909:2;10904:3;10900:12;10893:30;10949:2;10944:3;10940:12;10933:19;;10734:224;;;:::o;10964:326::-;;11127:67;11191:2;11186:3;11127:67;:::i;:::-;11120:74;;11224:30;11220:1;11215:3;11211:11;11204:51;11281:2;11276:3;11272:12;11265:19;;11110:180;;;:::o;11296:325::-;;11459:67;11523:2;11518:3;11459:67;:::i;:::-;11452:74;;11556:29;11552:1;11547:3;11543:11;11536:50;11612:2;11607:3;11603:12;11596:19;;11442:179;;;:::o;11627:324::-;;11790:67;11854:2;11849:3;11790:67;:::i;:::-;11783:74;;11887:28;11883:1;11878:3;11874:11;11867:49;11942:2;11937:3;11933:12;11926:19;;11773:178;;;:::o;11957:368::-;;12120:67;12184:2;12179:3;12120:67;:::i;:::-;12113:74;;12217:34;12213:1;12208:3;12204:11;12197:55;12283:6;12278:2;12273:3;12269:12;12262:28;12316:2;12311:3;12307:12;12300:19;;12103:222;;;:::o;12331:323::-;;12494:67;12558:2;12553:3;12494:67;:::i;:::-;12487:74;;12591:27;12587:1;12582:3;12578:11;12571:48;12645:2;12640:3;12636:12;12629:19;;12477:177;;;:::o;12660:370::-;;12823:67;12887:2;12882:3;12823:67;:::i;:::-;12816:74;;12920:34;12916:1;12911:3;12907:11;12900:55;12986:8;12981:2;12976:3;12972:12;12965:30;13021:2;13016:3;13012:12;13005:19;;12806:224;;;:::o;13036:376::-;;13199:67;13263:2;13258:3;13199:67;:::i;:::-;13192:74;;13296:34;13292:1;13287:3;13283:11;13276:55;13362:14;13357:2;13352:3;13348:12;13341:36;13403:2;13398:3;13394:12;13387:19;;13182:230;;;:::o;13418:388::-;;13581:67;13645:2;13640:3;13581:67;:::i;:::-;13574:74;;13678:34;13674:1;13669:3;13665:11;13658:55;13744:26;13739:2;13734:3;13730:12;13723:48;13797:2;13792:3;13788:12;13781:19;;13564:242;;;:::o;13812:374::-;;13975:67;14039:2;14034:3;13975:67;:::i;:::-;13968:74;;14072:34;14068:1;14063:3;14059:11;14052:55;14138:12;14133:2;14128:3;14124:12;14117:34;14177:2;14172:3;14168:12;14161:19;;13958:228;;;:::o;14192:366::-;;14355:67;14419:2;14414:3;14355:67;:::i;:::-;14348:74;;14452:34;14448:1;14443:3;14439:11;14432:55;14518:4;14513:2;14508:3;14504:12;14497:26;14549:2;14544:3;14540:12;14533:19;;14338:220;;;:::o;14564:330::-;;14727:67;14791:2;14786:3;14727:67;:::i;:::-;14720:74;;14824:34;14820:1;14815:3;14811:11;14804:55;14885:2;14880:3;14876:12;14869:19;;14710:184;;;:::o;14900:376::-;;15063:67;15127:2;15122:3;15063:67;:::i;:::-;15056:74;;15160:34;15156:1;15151:3;15147:11;15140:55;15226:14;15221:2;15216:3;15212:12;15205:36;15267:2;15262:3;15258:12;15251:19;;15046:230;;;:::o;15282:330::-;;15445:67;15509:2;15504:3;15445:67;:::i;:::-;15438:74;;15542:34;15538:1;15533:3;15529:11;15522:55;15603:2;15598:3;15594:12;15587:19;;15428:184;;;:::o;15618:373::-;;15781:67;15845:2;15840:3;15781:67;:::i;:::-;15774:74;;15878:34;15874:1;15869:3;15865:11;15858:55;15944:11;15939:2;15934:3;15930:12;15923:33;15982:2;15977:3;15973:12;15966:19;;15764:227;;;:::o;15997:379::-;;16160:67;16224:2;16219:3;16160:67;:::i;:::-;16153:74;;16257:34;16253:1;16248:3;16244:11;16237:55;16323:17;16318:2;16313:3;16309:12;16302:39;16367:2;16362:3;16358:12;16351:19;;16143:233;;;:::o;16382:365::-;;16545:67;16609:2;16604:3;16545:67;:::i;:::-;16538:74;;16642:34;16638:1;16633:3;16629:11;16622:55;16708:3;16703:2;16698:3;16694:12;16687:25;16738:2;16733:3;16729:12;16722:19;;16528:219;;;:::o;16753:381::-;;16916:67;16980:2;16975:3;16916:67;:::i;:::-;16909:74;;17013:34;17009:1;17004:3;17000:11;16993:55;17079:19;17074:2;17069:3;17065:12;17058:41;17125:2;17120:3;17116:12;17109:19;;16899:235;;;:::o;17140:327::-;;17303:67;17367:2;17362:3;17303:67;:::i;:::-;17296:74;;17400:31;17396:1;17391:3;17387:11;17380:52;17458:2;17453:3;17449:12;17442:19;;17286:181;;;:::o;17473:118::-;17560:24;17578:5;17560:24;:::i;:::-;17555:3;17548:37;17538:53;;:::o;17597:271::-;;17749:93;17838:3;17829:6;17749:93;:::i;:::-;17742:100;;17859:3;17852:10;;17731:137;;;;:::o;17874:435::-;;18076:95;18167:3;18158:6;18076:95;:::i;:::-;18069:102;;18188:95;18279:3;18270:6;18188:95;:::i;:::-;18181:102;;18300:3;18293:10;;18058:251;;;;;:::o;18315:222::-;;18446:2;18435:9;18431:18;18423:26;;18459:71;18527:1;18516:9;18512:17;18503:6;18459:71;:::i;:::-;18413:124;;;;:::o;18543:672::-;;18792:3;18781:9;18777:19;18769:27;;18806:87;18890:1;18879:9;18875:17;18866:6;18806:87;:::i;:::-;18903:72;18971:2;18960:9;18956:18;18947:6;18903:72;:::i;:::-;18985;19053:2;19042:9;19038:18;19029:6;18985:72;:::i;:::-;19104:9;19098:4;19094:20;19089:2;19078:9;19074:18;19067:48;19132:76;19203:4;19194:6;19132:76;:::i;:::-;19124:84;;18759:456;;;;;;;:::o;19221:210::-;;19346:2;19335:9;19331:18;19323:26;;19359:65;19421:1;19410:9;19406:17;19397:6;19359:65;:::i;:::-;19313:118;;;;:::o;19437:313::-;;19588:2;19577:9;19573:18;19565:26;;19637:9;19631:4;19627:20;19623:1;19612:9;19608:17;19601:47;19665:78;19738:4;19729:6;19665:78;:::i;:::-;19657:86;;19555:195;;;;:::o;19756:419::-;;19960:2;19949:9;19945:18;19937:26;;20009:9;20003:4;19999:20;19995:1;19984:9;19980:17;19973:47;20037:131;20163:4;20037:131;:::i;:::-;20029:139;;19927:248;;;:::o;20181:419::-;;20385:2;20374:9;20370:18;20362:26;;20434:9;20428:4;20424:20;20420:1;20409:9;20405:17;20398:47;20462:131;20588:4;20462:131;:::i;:::-;20454:139;;20352:248;;;:::o;20606:419::-;;20810:2;20799:9;20795:18;20787:26;;20859:9;20853:4;20849:20;20845:1;20834:9;20830:17;20823:47;20887:131;21013:4;20887:131;:::i;:::-;20879:139;;20777:248;;;:::o;21031:419::-;;21235:2;21224:9;21220:18;21212:26;;21284:9;21278:4;21274:20;21270:1;21259:9;21255:17;21248:47;21312:131;21438:4;21312:131;:::i;:::-;21304:139;;21202:248;;;:::o;21456:419::-;;21660:2;21649:9;21645:18;21637:26;;21709:9;21703:4;21699:20;21695:1;21684:9;21680:17;21673:47;21737:131;21863:4;21737:131;:::i;:::-;21729:139;;21627:248;;;:::o;21881:419::-;;22085:2;22074:9;22070:18;22062:26;;22134:9;22128:4;22124:20;22120:1;22109:9;22105:17;22098:47;22162:131;22288:4;22162:131;:::i;:::-;22154:139;;22052:248;;;:::o;22306:419::-;;22510:2;22499:9;22495:18;22487:26;;22559:9;22553:4;22549:20;22545:1;22534:9;22530:17;22523:47;22587:131;22713:4;22587:131;:::i;:::-;22579:139;;22477:248;;;:::o;22731:419::-;;22935:2;22924:9;22920:18;22912:26;;22984:9;22978:4;22974:20;22970:1;22959:9;22955:17;22948:47;23012:131;23138:4;23012:131;:::i;:::-;23004:139;;22902:248;;;:::o;23156:419::-;;23360:2;23349:9;23345:18;23337:26;;23409:9;23403:4;23399:20;23395:1;23384:9;23380:17;23373:47;23437:131;23563:4;23437:131;:::i;:::-;23429:139;;23327:248;;;:::o;23581:419::-;;23785:2;23774:9;23770:18;23762:26;;23834:9;23828:4;23824:20;23820:1;23809:9;23805:17;23798:47;23862:131;23988:4;23862:131;:::i;:::-;23854:139;;23752:248;;;:::o;24006:419::-;;24210:2;24199:9;24195:18;24187:26;;24259:9;24253:4;24249:20;24245:1;24234:9;24230:17;24223:47;24287:131;24413:4;24287:131;:::i;:::-;24279:139;;24177:248;;;:::o;24431:419::-;;24635:2;24624:9;24620:18;24612:26;;24684:9;24678:4;24674:20;24670:1;24659:9;24655:17;24648:47;24712:131;24838:4;24712:131;:::i;:::-;24704:139;;24602:248;;;:::o;24856:419::-;;25060:2;25049:9;25045:18;25037:26;;25109:9;25103:4;25099:20;25095:1;25084:9;25080:17;25073:47;25137:131;25263:4;25137:131;:::i;:::-;25129:139;;25027:248;;;:::o;25281:419::-;;25485:2;25474:9;25470:18;25462:26;;25534:9;25528:4;25524:20;25520:1;25509:9;25505:17;25498:47;25562:131;25688:4;25562:131;:::i;:::-;25554:139;;25452:248;;;:::o;25706:419::-;;25910:2;25899:9;25895:18;25887:26;;25959:9;25953:4;25949:20;25945:1;25934:9;25930:17;25923:47;25987:131;26113:4;25987:131;:::i;:::-;25979:139;;25877:248;;;:::o;26131:419::-;;26335:2;26324:9;26320:18;26312:26;;26384:9;26378:4;26374:20;26370:1;26359:9;26355:17;26348:47;26412:131;26538:4;26412:131;:::i;:::-;26404:139;;26302:248;;;:::o;26556:419::-;;26760:2;26749:9;26745:18;26737:26;;26809:9;26803:4;26799:20;26795:1;26784:9;26780:17;26773:47;26837:131;26963:4;26837:131;:::i;:::-;26829:139;;26727:248;;;:::o;26981:419::-;;27185:2;27174:9;27170:18;27162:26;;27234:9;27228:4;27224:20;27220:1;27209:9;27205:17;27198:47;27262:131;27388:4;27262:131;:::i;:::-;27254:139;;27152:248;;;:::o;27406:419::-;;27610:2;27599:9;27595:18;27587:26;;27659:9;27653:4;27649:20;27645:1;27634:9;27630:17;27623:47;27687:131;27813:4;27687:131;:::i;:::-;27679:139;;27577:248;;;:::o;27831:419::-;;28035:2;28024:9;28020:18;28012:26;;28084:9;28078:4;28074:20;28070:1;28059:9;28055:17;28048:47;28112:131;28238:4;28112:131;:::i;:::-;28104:139;;28002:248;;;:::o;28256:419::-;;28460:2;28449:9;28445:18;28437:26;;28509:9;28503:4;28499:20;28495:1;28484:9;28480:17;28473:47;28537:131;28663:4;28537:131;:::i;:::-;28529:139;;28427:248;;;:::o;28681:419::-;;28885:2;28874:9;28870:18;28862:26;;28934:9;28928:4;28924:20;28920:1;28909:9;28905:17;28898:47;28962:131;29088:4;28962:131;:::i;:::-;28954:139;;28852:248;;;:::o;29106:222::-;;29237:2;29226:9;29222:18;29214:26;;29250:71;29318:1;29307:9;29303:17;29294:6;29250:71;:::i;:::-;29204:124;;;;:::o;29334:278::-;;29400:2;29394:9;29384:19;;29442:4;29434:6;29430:17;29549:6;29537:10;29534:22;29513:18;29501:10;29498:34;29495:62;29492:2;;;29560:13;;:::i;:::-;29492:2;29595:10;29591:2;29584:22;29374:238;;;;:::o;29618:306::-;;29785:18;29777:6;29774:30;29771:2;;;29807:13;;:::i;:::-;29771:2;29852:4;29844:6;29840:17;29832:25;;29912:4;29906;29902:15;29894:23;;29700:224;;;:::o;29930:326::-;;30081:18;30073:6;30070:30;30067:2;;;30103:13;;:::i;:::-;30067:2;30183:4;30179:9;30172:4;30164:6;30160:17;30156:33;30148:41;;30244:4;30238;30234:15;30226:23;;29996:260;;;:::o;30262:327::-;;30414:18;30406:6;30403:30;30400:2;;;30436:13;;:::i;:::-;30400:2;30516:4;30512:9;30505:4;30497:6;30493:17;30489:33;30481:41;;30577:4;30571;30567:15;30559:23;;30329:260;;;:::o;30595:98::-;;30680:5;30674:12;30664:22;;30653:40;;;:::o;30699:99::-;;30785:5;30779:12;30769:22;;30758:40;;;:::o;30804:168::-;;30921:6;30916:3;30909:19;30961:4;30956:3;30952:14;30937:29;;30899:73;;;;:::o;30978:147::-;;31116:3;31101:18;;31091:34;;;;:::o;31131:169::-;;31249:6;31244:3;31237:19;31289:4;31284:3;31280:14;31265:29;;31227:73;;;;:::o;31306:148::-;;31445:3;31430:18;;31420:34;;;;:::o;31460:96::-;;31526:24;31544:5;31526:24;:::i;:::-;31515:35;;31505:51;;;:::o;31562:104::-;;31636:24;31654:5;31636:24;:::i;:::-;31625:35;;31615:51;;;:::o;31672:90::-;;31749:5;31742:13;31735:21;31724:32;;31714:48;;;:::o;31768:149::-;;31844:66;31837:5;31833:78;31822:89;;31812:105;;;:::o;31923:126::-;;32000:42;31993:5;31989:54;31978:65;;31968:81;;;:::o;32055:77::-;;32121:5;32110:16;;32100:32;;;:::o;32138:154::-;32222:6;32217:3;32212;32199:30;32284:1;32275:6;32270:3;32266:16;32259:27;32189:103;;;:::o;32298:307::-;32366:1;32376:113;32390:6;32387:1;32384:13;32376:113;;;32475:1;32470:3;32466:11;32460:18;32456:1;32451:3;32447:11;32440:39;32412:2;32409:1;32405:10;32400:15;;32376:113;;;32507:6;32504:1;32501:13;32498:2;;;32587:1;32578:6;32573:3;32569:16;32562:27;32498:2;32347:258;;;;:::o;32611:48::-;32644:9;32665:102;;32757:2;32753:7;32748:2;32741:5;32737:14;32733:28;32723:38;;32713:54;;;:::o;32773:122::-;32846:24;32864:5;32846:24;:::i;:::-;32839:5;32836:35;32826:2;;32885:1;32882;32875:12;32826:2;32816:79;:::o;32901:116::-;32971:21;32986:5;32971:21;:::i;:::-;32964:5;32961:32;32951:2;;33007:1;33004;32997:12;32951:2;32941:76;:::o;33023:120::-;33095:23;33112:5;33095:23;:::i;:::-;33088:5;33085:34;33075:2;;33133:1;33130;33123:12;33075:2;33065:78;:::o;33149:122::-;33222:24;33240:5;33222:24;:::i;:::-;33215:5;33212:35;33202:2;;33261:1;33258;33251:12;33202:2;33192:79;:::o

Swarm Source

ipfs://99117913a27e3bfa63223ac2fb790973b981a53abb9e77fcb268317ffc9c11da

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