Token

NFT RedZone (NFTRZ)

ERC-721

Overview

Max Total Supply

3,734 NFTRZ

Holders

683

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xa96602e7f43b8b01d3a746bf2e178ef6dde7880d

Filtered by Token Holder

0xD2D06C5b3f8Aad0375a6e24619C1535F3cE1c364

sundevils0348.eth

Balance

1 NFTRZ

0xd2d06c5b3f8aad0375a6e24619c1535f3ce1c364

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

NFTRedZone

Compiler Version

v0.7.6+commit.7338295f

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-09-22
*/

// File: node_modules\@openzeppelin\contracts\GSN\Context.sol

pragma solidity >=0.6.0 <0.8.0;

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

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

// File: node_modules\@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: node_modules\@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: node_modules\@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: node_modules\@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: node_modules\@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: node_modules\@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 () internal {
        // 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 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: node_modules\@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, 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) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * 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);
        uint256 c = a - b;

        return c;
    }

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

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) {
        return div(a, b, "SafeMath: division by zero");
    }

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

        return c;
    }

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

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: node_modules\@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);
    }

    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: node_modules\@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(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(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(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(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: node_modules\@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 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) {
        return _get(map, key, "EnumerableMap: nonexistent key");
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     */
    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(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(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(uint256(_get(map._inner, bytes32(key))));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     */
    function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
        return address(uint256(_get(map._inner, bytes32(key), errorMessage)));
    }
}

// File: node_modules\@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--] = byte(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_) public {
        _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 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 override returns (address) {
        return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
    }

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

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

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

        string memory _tokenURI = _tokenURIs[tokenId];

        // If there is no base URI, return the token URI.
        if (bytes(_baseURI).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(_baseURI, _tokenURI));
        }
        // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
        return string(abi.encodePacked(_baseURI, 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 returns (string memory) {
        return _baseURI;
    }

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

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view 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 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 = ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

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

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view 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 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 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 returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || 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 = ownerOf(tokenId);

        _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(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

        _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);
    }

    function _approve(address to, uint256 tokenId) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(ownerOf(tokenId), to, tokenId);
    }

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

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

pragma solidity >=0.6.0 <0.8.0;

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view 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;
    }
}

// File: contracts\NFTRedZone.sol


pragma solidity 0.7.6;
pragma abicoder v2;

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

    struct Whitelist {
        bool approved;
        uint256 minted;
    }

    uint256 constant public TOTAL_TOKEN_TO_MINT = 7216;
    uint256 constant public TOTAL_USER_ELIGIBLE_FOR_REFUND = 1400;
    uint256 constant public WHITELIST_MINT_PER_USER = 20;
    uint256 constant public ITEM_PRICE = 0.07 ether; // 0.07 ETH;
    bool public isSaleActive;
    bool public isPreSaleActive;
    bool public isBurnRefundActive;
	uint256 public mintedTokens;
	uint256 public burnedTokens;
    uint256 public startingIpfsId;
    address public fundWallet;
    uint256 private _lastIpfsId;

    mapping(address => Whitelist) public whitelistInfo;

    modifier beforeMint(uint256 _howMany) {
	    require(_howMany > 0, "NFTRedZone: Minimum 1 tokens need to be minted");
	    require(_howMany <= tokenRemainingToBeMinted(), "NFTRedZone: Mint amount is greater than the token available");
		require(_howMany <= 20, "NFTRedZone: Max 20 tokens at once");
		require(ITEM_PRICE.mul(_howMany) == msg.value, "NFTRedZone: Insufficient ETH to mint");
        _;
    }

    constructor (string memory _tokenBaseUri, address _fundWallet) ERC721("NFT RedZone", "NFTRZ") {
        _setBaseURI(_tokenBaseUri);
        fundWallet = _fundWallet;
    }

    ////////////////////
    // Action methods //
    ////////////////////

	function mintNFTRZ(uint256 _howMany) beforeMint(_howMany) external payable {
        require(isSaleActive, "NFTRedZone: Sale is not active");
		for (uint256 i = 0; i < _howMany; i++) {
			_mintNFTRZ(_msgSender());
		}
	}

    function presaleMint(uint256 _howMany) beforeMint(_howMany) external payable {
        require(isPreSaleActive, "NFTRedZone: Presale is not active");
	    require(isWhitelisted(_msgSender()), "NFTRedZone: You are not whitelist to mint in presale");
        require(whitelistUserMint(_msgSender()) < WHITELIST_MINT_PER_USER, "NFTRedZone: Presale max limit exceeds");
		for (uint256 i = 0; i < _howMany; i++) {
            require(whitelistUserMint(_msgSender()) < WHITELIST_MINT_PER_USER, "NFTRedZone: Presale max limit exceeds");
            _mintNFTRZ(_msgSender());
            whitelistInfo[_msgSender()].minted++;
		}
	}
    
    function _mintNFTRZ(address _to) private {
        if(mintedTokens == 0) {
            _lastIpfsId = random(1, TOTAL_TOKEN_TO_MINT, uint256(uint160(address(_msgSender()))) + 1);
            startingIpfsId = _lastIpfsId;
        } else {
            _lastIpfsId = getIpfsIdToMint();
        }
        mintedTokens++;
        require(!_exists(mintedTokens), "NFTRedZone: Token already exist.");
        _mint(_to, mintedTokens);
        _setTokenURI(mintedTokens, uint2str(_lastIpfsId));
    }

    function uint2str(uint256 _i) private pure returns (string memory _uintAsString) {
		if (_i == 0) {
			return "0";
		}
		uint256 j = _i;
		uint256 len;
		while (j != 0) {
			len++;
			j /= 10;
		}
		bytes memory bstr = new bytes(len);
		uint256 k = len;
		while (_i != 0) {
			k = k - 1;
			uint8 temp = (48 + uint8(_i - (_i / 10) * 10));
			bytes1 b1 = bytes1(temp);
			bstr[k] = b1;
			_i /= 10;
		}
		return string(bstr);
	}

    function burn(uint256 tokenId) public {
        require(_exists(tokenId), "NFTRedZone: token does not exist.");
        require(_isApprovedOrOwner(_msgSender(), tokenId), "NFTRedZone: caller is not owner nor approved");
        _burn(tokenId);
    }

    function burnRefund(uint256 tokenId) public {
        require(isBurnRefundActive, "NFTRedZone: Feature is not active");
	    require(burnedTokens < TOTAL_USER_ELIGIBLE_FOR_REFUND, "NFTRedZone: Maximum token have been burned to claim refund");
        burn(tokenId);
        burnedTokens++;
        payable(_msgSender()).transfer(ITEM_PRICE);
    }

    ///////////////////
    // Query methods //
    ///////////////////

    function exists(uint256 _tokenId) external view returns (bool) {
        return _exists(_tokenId);
    }

    function isWhitelisted(address _address) public view returns(bool) {
        return whitelistInfo[_address].approved;
    }

    function whitelistUserMint(address _address) public view returns(uint256) {
        return whitelistInfo[_address].minted;
    }
    
    function tokenRemainingToBeMinted() public view returns (uint256) {
        return TOTAL_TOKEN_TO_MINT.sub(mintedTokens);
    }

    function isAllTokenMinted() public view returns (bool) {
        return mintedTokens == TOTAL_TOKEN_TO_MINT;
    }

    function getIpfsIdToMint() public view returns(uint256 _nextIpfsId) {
        require(!isAllTokenMinted(), "NFTRedZone: All tokens have been minted");
        if(_lastIpfsId == TOTAL_TOKEN_TO_MINT && mintedTokens < TOTAL_TOKEN_TO_MINT) {
            _nextIpfsId = 1;
        } else if(mintedTokens < TOTAL_TOKEN_TO_MINT) {
            _nextIpfsId = _lastIpfsId + 1;
        }
    }

    function isApprovedOrOwner(address _spender, uint256 _tokenId) external view returns (bool) {
        return _isApprovedOrOwner(_spender, _tokenId);
    }

    //random number
	function random(
		uint256 from,
		uint256 to,
		uint256 salty
	) public view returns (uint256) {
		uint256 seed =
			uint256(
				keccak256(
					abi.encodePacked(
						block.timestamp +
							block.difficulty +
							((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (block.timestamp)) +
							block.gaslimit +
							((uint256(keccak256(abi.encodePacked(_msgSender())))) / (block.timestamp)) +
							block.number +
							salty
					)
				)
			);
		return seed.mod(to - from) + from;
	}

    /////////////
    // Setters //
    /////////////

    function addToWhitelistMultiple(address[] memory _addresses) external onlyOwner {
        for(uint256 i = 0; i < _addresses.length; i++) {
            addToWhitelist(_addresses[i]);
        }
    }

    function addToWhitelist(address _address) public onlyOwner {
        whitelistInfo[_address].approved = true;
    }

    function removeFromWhitelist(address _address) external onlyOwner {
        whitelistInfo[_address].approved = false;
    }

    function stopSale() external onlyOwner {
        isSaleActive = false;
    }

    function startSale() external onlyOwner {
        isSaleActive = true;
    }

    function startPreSale() external onlyOwner {
        isPreSaleActive = true;
    }

    function stopPreSale() external onlyOwner {
        isPreSaleActive = false;
    }

    function startBurnRefund() external onlyOwner {
        isBurnRefundActive = true;
    }

    function stopBurnRefund() external onlyOwner {
        isBurnRefundActive = false;
    }

    function changeFundWallet(address _fundWallet) external onlyOwner {
        fundWallet = _fundWallet;
    }

    function withdrawETH(uint256 _amount) external onlyOwner {
        payable(fundWallet).transfer(_amount);
    }

    function setTokenURI(uint256 _tokenId, string memory _uri) external onlyOwner {
        _setTokenURI(_tokenId, _uri);
    }

    function setBaseURI(string memory _baseURI) external onlyOwner {
        _setBaseURI(_baseURI);
    }

    function _beforeTokenTransfer(address _from, address _to, uint256 _tokenId) internal virtual override(ERC721) {
        super._beforeTokenTransfer(_from, _to, _tokenId);
    }
    
    receive() payable external {
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_tokenBaseUri","type":"string"},{"internalType":"address","name":"_fundWallet","type":"address"}],"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":"ITEM_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOTAL_TOKEN_TO_MINT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOTAL_USER_ELIGIBLE_FOR_REFUND","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WHITELIST_MINT_PER_USER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"addToWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_addresses","type":"address[]"}],"name":"addToWhitelistMultiple","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":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burnRefund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"burnedTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_fundWallet","type":"address"}],"name":"changeFundWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fundWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getIpfsIdToMint","outputs":[{"internalType":"uint256","name":"_nextIpfsId","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isAllTokenMinted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"isApprovedOrOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isBurnRefundActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isPreSaleActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isSaleActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"isWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_howMany","type":"uint256"}],"name":"mintNFTRZ","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintedTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_howMany","type":"uint256"}],"name":"presaleMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"},{"internalType":"uint256","name":"salty","type":"uint256"}],"name":"random","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"removeFromWhitelist","outputs":[],"stateMutability":"nonpayable","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":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"string","name":"_uri","type":"string"}],"name":"setTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBurnRefund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startPreSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startingIpfsId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stopBurnRefund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stopPreSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stopSale","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":[],"name":"tokenRemainingToBeMinted","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":[{"internalType":"address","name":"","type":"address"}],"name":"whitelistInfo","outputs":[{"internalType":"bool","name":"approved","type":"bool"},{"internalType":"uint256","name":"minted","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"whitelistUserMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000828a0dedc21e0cfa61809c72512a260d8aff173a000000000000000000000000000000000000000000000000000000000000005668747470733a2f2f6e66747265647a6f6e652e6d7970696e6174612e636c6f75642f697066732f516d56763264747032554538767367524a46366f3639616635646f44334d783459684748754170704272343476582f00000000000000000000

-----Decoded View---------------
Arg [0] : _tokenBaseUri (string): https://nftredzone.mypinata.cloud/ipfs/QmVv2dtp2UE8vsgRJF6o69af5doD3Mx4YhGHuAppBr44vX/
Arg [1] : _fundWallet (address): 0x828A0DeDc21e0cfA61809c72512a260D8afF173a

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 000000000000000000000000828a0dedc21e0cfa61809c72512a260d8aff173a
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000056
Arg [3] : 68747470733a2f2f6e66747265647a6f6e652e6d7970696e6174612e636c6f75
Arg [4] : 642f697066732f516d56763264747032554538767367524a46366f3639616635
Arg [5] : 646f44334d783459684748754170704272343476582f00000000000000000000

Deployed Bytecode Sourcemap

62034:7506:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10263:142;;;;;;;;;;-1:-1:-1;10263:142:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47036:92;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;49723:213::-;;;;;;;;;;-1:-1:-1;49723:213:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;49267:390::-;;;;;;;;;;-1:-1:-1;49267:390:0;;;;;:::i;:::-;;:::i;:::-;;69069:125;;;;;;;;;;-1:-1:-1;69069:125:0;;;;;:::i;:::-;;:::i;48761:203::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;68635:90::-;;;;;;;;;;;;;:::i;50597:305::-;;;;;;;;;;-1:-1:-1;50597:305:0;;;;;:::i;:::-;;:::i;63453:225::-;;;;;;:::i;:::-;;:::i;62322:52::-;;;;;;;;;;;;;:::i;48531:154::-;;;;;;;;;;-1:-1:-1;48531:154:0;;;;;:::i;:::-;;:::i;65557:353::-;;;;;;;;;;-1:-1:-1;65557:353:0;;;;;:::i;:::-;;:::i;66109:125::-;;;;;;;;;;-1:-1:-1;66109:125:0;;;;;:::i;:::-;;:::i;62254:61::-;;;;;;;;;;;;;:::i;50973:151::-;;;;;;;;;;-1:-1:-1;50973:151:0;;;;;:::i;:::-;;:::i;65296:253::-;;;;;;;;;;-1:-1:-1;65296:253:0;;;;;:::i;:::-;;:::i;67041:156::-;;;;;;;;;;-1:-1:-1;67041:156:0;;;;;:::i;:::-;;:::i;62578:27::-;;;;;;;;;;;;;:::i;65995:106::-;;;;;;;;;;-1:-1:-1;65995:106:0;;;;;:::i;:::-;;:::i;49041:164::-;;;;;;;;;;-1:-1:-1;49041:164:0;;;;;:::i;:::-;;:::i;68451:84::-;;;;;;;;;;;;;:::i;69202:103::-;;;;;;;;;;-1:-1:-1;69202:103:0;;;;;:::i;:::-;;:::i;62448:24::-;;;;;;;;;;;;;:::i;46800:169::-;;;;;;;;;;-1:-1:-1;46800:169:0;;;;;:::i;:::-;;:::i;62648:25::-;;;;;;;;;;;;;:::i;62381:47::-;;;;;;;;;;;;;:::i;48358:89::-;;;;;;;;;;;;;:::i;62197:50::-;;;;;;;;;;;;;:::i;68831:109::-;;;;;;;;;;-1:-1:-1;68831:109:0;;;;;:::i;:::-;;:::i;68733:90::-;;;;;;;;;;;;;:::i;46523:215::-;;;;;;;;;;-1:-1:-1;46523:215:0;;;;;:::i;:::-;;:::i;61394:148::-;;;;;;;;;;;;;:::i;67223:522::-;;;;;;;;;;-1:-1:-1;67223:522:0;;;;;:::i;:::-;;:::i;66242:130::-;;;;;;;;;;-1:-1:-1;66242:130:0;;;;;:::i;:::-;;:::i;68146:125::-;;;;;;;;;;-1:-1:-1;68146:125:0;;;;;:::i;:::-;;:::i;62547:27::-;;;;;;;;;;;;;:::i;60752:79::-;;;;;;;;;;;;;:::i;62612:29::-;;;;;;;;;;;;;:::i;67812:201::-;;;;;;;;;;-1:-1:-1;67812:201:0;;;;;:::i;:::-;;:::i;47197:96::-;;;;;;;;;;;;;:::i;62479:27::-;;;;;;;;;;;;;:::i;62513:30::-;;;;;;;;;;;;;:::i;50008:295::-;;;;;;;;;;-1:-1:-1;50008:295:0;;;;;:::i;:::-;;:::i;66521:116::-;;;;;;;;;;;;;:::i;68365:78::-;;;;;;;;;;;;;:::i;51195:285::-;;;;;;;;;;-1:-1:-1;51195:285:0;;;;;:::i;:::-;;:::i;66645:388::-;;;;;;;;;;;;;:::i;62716:50::-;;;;;;;;;;-1:-1:-1;62716:50:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;66384:129::-;;;;;;;;;;;;;:::i;47364:755::-;;;;;;;;;;-1:-1:-1;47364:755:0;;;;;:::i;:::-;;:::i;63686:633::-;;;;;;:::i;:::-;;:::i;68279:78::-;;;;;;;;;;;;;:::i;68021:117::-;;;;;;;;;;-1:-1:-1;68021:117:0;;;;;:::i;:::-;;:::i;50374:156::-;;;;;;;;;;-1:-1:-1;50374:156:0;;;;;:::i;:::-;;:::i;68948:113::-;;;;;;;;;;-1:-1:-1;68948:113:0;;;;;:::i;:::-;;:::i;61697:244::-;;;;;;;;;;-1:-1:-1;61697:244:0;;;;;:::i;:::-;;:::i;68543:84::-;;;;;;;;;;;;;:::i;10263:142::-;-1:-1:-1;;;;;;10364:33:0;;10340:4;10364:33;;;;;;;;;;;;;10263:142;;;;:::o;47036:92::-;47115:5;47108:12;;;;;;;;-1:-1:-1;;47108:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47082:13;;47108:12;;47115:5;;47108:12;;47115:5;47108:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47036:92;;:::o;49723:213::-;49791:7;49819:16;49827:7;49819;:16::i;:::-;49811:73;;;;-1:-1:-1;;;49811:73:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;49904:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;49904:24:0;;49723:213::o;49267:390::-;49348:13;49364:16;49372:7;49364;:16::i;:::-;49348:32;;49405:5;-1:-1:-1;;;;;49399:11:0;:2;-1:-1:-1;;;;;49399:11:0;;;49391:57;;;;-1:-1:-1;;;49391:57:0;;;;;;;:::i;:::-;49485:5;-1:-1:-1;;;;;49469:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;49469:21:0;;:62;;;;49494:37;49511:5;49518:12;:10;:12::i;49494:37::-;49461:154;;;;-1:-1:-1;;;49461:154:0;;;;;;;:::i;:::-;49628:21;49637:2;49641:7;49628:8;:21::i;:::-;49267:390;;;:::o;69069:125::-;60974:12;:10;:12::i;:::-;60964:6;;-1:-1:-1;;;;;60964:6:0;;;:22;;;60956:67;;;;-1:-1:-1;;;60956:67:0;;;;;;;:::i;:::-;69158:28:::1;69171:8;69181:4;69158:12;:28::i;:::-;69069:125:::0;;:::o;48761:203::-;48814:7;48935:21;:12;:19;:21::i;:::-;48928:28;;48761:203;:::o;68635:90::-;60974:12;:10;:12::i;:::-;60964:6;;-1:-1:-1;;;;;60964:6:0;;;:22;;;60956:67;;;;-1:-1:-1;;;60956:67:0;;;;;;;:::i;:::-;68692:18:::1;:25:::0;;-1:-1:-1;;;;68692:25:0::1;-1:-1:-1::0;;;68692:25:0::1;::::0;;68635:90::o;50597:305::-;50758:41;50777:12;:10;:12::i;:::-;50791:7;50758:18;:41::i;:::-;50750:103;;;;-1:-1:-1;;;50750:103:0;;;;;;;:::i;:::-;50866:28;50876:4;50882:2;50886:7;50866:9;:28::i;63453:225::-;63501:8;62840:1;62829:8;:12;62821:71;;;;-1:-1:-1;;;62821:71:0;;;;;;;:::i;:::-;62920:26;:24;:26::i;:::-;62908:8;:38;;62900:110;;;;-1:-1:-1;;;62900:110:0;;;;;;;:::i;:::-;63035:2;63023:8;:14;;63015:60;;;;-1:-1:-1;;;63015:60:0;;;;;;;:::i;:::-;63116:9;63088:24;62418:10;63103:8;63088:14;:24::i;:::-;:37;63080:86;;;;-1:-1:-1;;;63080:86:0;;;;;;;:::i;:::-;63547:12:::1;::::0;-1:-1:-1;;;63547:12:0;::::1;;;63539:55;;;;-1:-1:-1::0;;;63539:55:0::1;;;;;;;:::i;:::-;63604:9;63599:75;63623:8;63619:1;:12;63599:75;;;63644:24;63655:12;:10;:12::i;:::-;63644:10;:24::i;:::-;63633:3;;63599:75;;62322:52:::0;62372:2;62322:52;:::o;48531:154::-;-1:-1:-1;;;;;48647:20:0;;48620:7;48647:20;;;:13;:20;;;;;:30;;48671:5;48647:23;:30::i;:::-;48640:37;;48531:154;;;;;:::o;65557:353::-;65620:18;;-1:-1:-1;;;65620:18:0;;;;65612:64;;;;-1:-1:-1;;;65612:64:0;;;;;;;:::i;:::-;62311:4;65692:12;;:45;65684:116;;;;-1:-1:-1;;;65684:116:0;;;;;;;:::i;:::-;65811:13;65816:7;65811:4;:13::i;:::-;65835:12;:14;;;;;;65868:12;:10;:12::i;:::-;65860:42;;-1:-1:-1;;;;;65860:30:0;;;;;:42;;62418:10;;65860:42;;;;62418:10;65860:30;:42;;;;;;;;;;;;;;;;;;;66109:125;-1:-1:-1;;;;;66194:23:0;66170:4;66194:23;;;:13;:23;;;;;:32;;;;66109:125::o;62254:61::-;62311:4;62254:61;:::o;50973:151::-;51077:39;51094:4;51100:2;51104:7;51077:39;;;;;;;;;;;;:16;:39::i;65296:253::-;65353:16;65361:7;65353;:16::i;:::-;65345:62;;;;-1:-1:-1;;;65345:62:0;;;;;;;:::i;:::-;65426:41;65445:12;:10;:12::i;65426:41::-;65418:98;;;;-1:-1:-1;;;65418:98:0;;;;;;;:::i;:::-;65527:14;65533:7;65527:5;:14::i;:::-;65296:253;:::o;67041:156::-;67127:4;67151:38;67170:8;67180;67151:18;:38::i;62578:27::-;;;;:::o;65995:106::-;66052:4;66076:17;66084:8;66076:7;:17::i;49041:164::-;49108:7;;49150:22;:12;49166:5;49150:15;:22::i;:::-;-1:-1:-1;49128:44:0;49041:164;-1:-1:-1;;;49041:164:0:o;68451:84::-;60974:12;:10;:12::i;:::-;60964:6;;-1:-1:-1;;;;;60964:6:0;;;:22;;;60956:67;;;;-1:-1:-1;;;60956:67:0;;;;;;;:::i;:::-;68505:15:::1;:22:::0;;-1:-1:-1;;;;68505:22:0::1;-1:-1:-1::0;;;68505:22:0::1;::::0;;68451:84::o;69202:103::-;60974:12;:10;:12::i;:::-;60964:6;;-1:-1:-1;;;;;60964:6:0;;;:22;;;60956:67;;;;-1:-1:-1;;;60956:67:0;;;;;;;:::i;:::-;69276:21:::1;69288:8;69276:11;:21::i;62448:24::-:0;;;-1:-1:-1;;;62448:24:0;;;;;:::o;46800:169::-;46864:7;46891:70;46908:7;46891:70;;;;;;;;;;;;;;;;;:12;;:70;:16;:70::i;62648:25::-;;;-1:-1:-1;;;;;62648:25:0;;:::o;62381:47::-;62418:10;62381:47;:::o;48358:89::-;48431:8;48424:15;;;;;;;;-1:-1:-1;;48424:15:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48398:13;;48424:15;;48431:8;;48424:15;;48431:8;48424:15;;;;;;;;;;;;;;;;;;;;;;;;62197:50;62243:4;62197:50;:::o;68831:109::-;60974:12;:10;:12::i;:::-;60964:6;;-1:-1:-1;;;;;60964:6:0;;;:22;;;60956:67;;;;-1:-1:-1;;;60956:67:0;;;;;;;:::i;:::-;68908:10:::1;:24:::0;;-1:-1:-1;;;;;;68908:24:0::1;-1:-1:-1::0;;;;;68908:24:0;;;::::1;::::0;;;::::1;::::0;;68831:109::o;68733:90::-;60974:12;:10;:12::i;:::-;60964:6;;-1:-1:-1;;;;;60964:6:0;;;:22;;;60956:67;;;;-1:-1:-1;;;60956:67:0;;;;;;;:::i;:::-;68789:18:::1;:26:::0;;-1:-1:-1;;;;68789:26:0::1;::::0;;68733:90::o;46523:215::-;46587:7;-1:-1:-1;;;;;46615:19:0;;46607:74;;;;-1:-1:-1;;;46607:74:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;46701:20:0;;;;;;:13;:20;;;;;:29;;:27;:29::i;61394:148::-;60974:12;:10;:12::i;:::-;60964:6;;-1:-1:-1;;;;;60964:6:0;;;:22;;;60956:67;;;;-1:-1:-1;;;60956:67:0;;;;;;;:::i;:::-;61485:6:::1;::::0;61464:40:::1;::::0;61501:1:::1;::::0;-1:-1:-1;;;;;61485:6:0::1;::::0;61464:40:::1;::::0;61501:1;;61464:40:::1;61515:6;:19:::0;;-1:-1:-1;;;;;;61515:19:0::1;::::0;;61394:148::o;67223:522::-;67314:7;67328:12;67676:5;67653:12;67625:15;67605:12;:10;:12::i;:::-;67588:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;67578:41;;;;;;67570:50;;67569:72;;;;;;67543:14;67515:15;67493:14;67476:32;;;;;;;;:::i;:::-;;;;;;;;;;;;;67466:43;;;;;;67458:52;;67457:74;;;;;;67429:16;67403:15;:42;:129;:154;:239;:262;:278;67378:311;;;;;;;;:::i;:::-;;;;-1:-1:-1;;67378:311:0;;;;;;;;;67361:335;;67378:311;67361:335;;;;;-1:-1:-1;67736:4:0;67714:19;67361:335;67723:9;;;67714:8;:19::i;:::-;:26;67707:33;;;67223:522;;;;;;:::o;66242:130::-;-1:-1:-1;;;;;66334:23:0;66307:7;66334:23;;;:13;:23;;;;;:30;;;;66242:130::o;68146:125::-;60974:12;:10;:12::i;:::-;60964:6;;-1:-1:-1;;;;;60964:6:0;;;:22;;;60956:67;;;;-1:-1:-1;;;60956:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;68223:23:0::1;68258:5;68223:23:::0;;;:13:::1;:23;::::0;;;;:40;;-1:-1:-1;;68223:40:0::1;::::0;;68146:125::o;62547:27::-;;;;:::o;60752:79::-;60817:6;;-1:-1:-1;;;;;60817:6:0;60752:79;:::o;62612:29::-;;;;:::o;67812:201::-;60974:12;:10;:12::i;:::-;60964:6;;-1:-1:-1;;;;;60964:6:0;;;:22;;;60956:67;;;;-1:-1:-1;;;60956:67:0;;;;;;;:::i;:::-;67907:9:::1;67903:103;67926:10;:17;67922:1;:21;67903:103;;;67965:29;67980:10;67991:1;67980:13;;;;;;;;;;;;;;67965:14;:29::i;:::-;67945:3;;67903:103;;47197:96:::0;47278:7;47271:14;;;;;;;;-1:-1:-1;;47271:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47245:13;;47271:14;;47278:7;;47271:14;;47278:7;47271:14;;;;;;;;;;;;;;;;;;;;;;;;62479:27;;;-1:-1:-1;;;62479:27:0;;;;;:::o;62513:30::-;;;-1:-1:-1;;;62513:30:0;;;;;:::o;50008:295::-;50123:12;:10;:12::i;:::-;-1:-1:-1;;;;;50111:24:0;:8;-1:-1:-1;;;;;50111:24:0;;;50103:62;;;;-1:-1:-1;;;50103:62:0;;;;;;;:::i;:::-;50223:8;50178:18;:32;50197:12;:10;:12::i;:::-;-1:-1:-1;;;;;50178:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;50178:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;50178:53:0;;;;;;;;;;;50262:12;:10;:12::i;:::-;-1:-1:-1;;;;;50247:48:0;;50286:8;50247:48;;;;;;:::i;:::-;;;;;;;;50008:295;;:::o;66521:116::-;66594:12;;62243:4;66594:35;66521:116;:::o;68365:78::-;60974:12;:10;:12::i;:::-;60964:6;;-1:-1:-1;;;;;60964:6:0;;;:22;;;60956:67;;;;-1:-1:-1;;;60956:67:0;;;;;;;:::i;:::-;68416:12:::1;:19:::0;;-1:-1:-1;;;;68416:19:0::1;-1:-1:-1::0;;;68416:19:0::1;::::0;;68365:78::o;51195:285::-;51327:41;51346:12;:10;:12::i;:::-;51360:7;51327:18;:41::i;:::-;51319:103;;;;-1:-1:-1;;;51319:103:0;;;;;;;:::i;:::-;51433:39;51447:4;51453:2;51457:7;51466:5;51433:13;:39::i;:::-;51195:285;;;;:::o;66645:388::-;66692:19;66733:18;:16;:18::i;:::-;66732:19;66724:71;;;;-1:-1:-1;;;66724:71:0;;;;;;;:::i;:::-;62243:4;66809:11;;:34;:72;;;;;62243:4;66847:12;;:34;66809:72;66806:220;;;-1:-1:-1;66912:1:0;66806:220;;;62243:4;66934:12;;:34;66931:95;;;-1:-1:-1;66999:11:0;;67013:1;66999:15;66645:388;:::o;62716:50::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;66384:129::-;66441:7;66468:37;66492:12;;62243:4;66468:23;;:37;;;;:::i;47364:755::-;47429:13;47463:16;47471:7;47463;:16::i;:::-;47455:76;;;;-1:-1:-1;;;47455:76:0;;;;;;;:::i;:::-;47544:23;47570:19;;;:10;:19;;;;;;;;47544:45;;;;;;;;;;;-1:-1:-1;;47544:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;47570:19;;47544:45;;;47570:19;47544:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;47671:8:0;47665:22;47544:45;;-1:-1:-1;;;;47665:22:0;-1:-1:-1;;47665:22:0;;;;;;;;;;;47661:76;;47716:9;-1:-1:-1;47709:16:0;;47661:76;47841:23;;:27;47837:112;;47916:8;47926:9;47899:37;;;;;;;;;:::i;:::-;;;;;;;;;;;;;47885:52;;;;;47837:112;48081:8;48091:18;:7;:16;:18::i;:::-;48064:46;;;;;;;;;:::i;:::-;;;;;;;;;;;;;48050:61;;;47364:755;;;:::o;63686:633::-;63736:8;62840:1;62829:8;:12;62821:71;;;;-1:-1:-1;;;62821:71:0;;;;;;;:::i;:::-;62920:26;:24;:26::i;:::-;62908:8;:38;;62900:110;;;;-1:-1:-1;;;62900:110:0;;;;;;;:::i;:::-;63035:2;63023:8;:14;;63015:60;;;;-1:-1:-1;;;63015:60:0;;;;;;;:::i;:::-;63116:9;63088:24;62418:10;63103:8;63088:14;:24::i;:::-;:37;63080:86;;;;-1:-1:-1;;;63080:86:0;;;;;;;:::i;:::-;63782:15:::1;::::0;-1:-1:-1;;;63782:15:0;::::1;;;63774:61;;;;-1:-1:-1::0;;;63774:61:0::1;;;;;;;:::i;:::-;63851:27;63865:12;:10;:12::i;63851:27::-;63843:92;;;;-1:-1:-1::0;;;63843:92:0::1;;;;;;;:::i;:::-;62372:2;63954:31;63972:12;:10;:12::i;63954:31::-;:57;63946:107;;;;-1:-1:-1::0;;;63946:107:0::1;;;;;;;:::i;:::-;64063:9;64058:257;64082:8;64078:1;:12;64058:257;;;62372:2;64120:31;64138:12;:10;:12::i;64120:31::-;:57;64112:107;;;;-1:-1:-1::0;;;64112:107:0::1;;;;;;;:::i;:::-;64234:24;64245:12;:10;:12::i;64234:24::-;64273:13;:27;64287:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;64273:27:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;64273:27:0;:34:::1;::::0;;::::1;:36:::0;;;::::1;::::0;;64092:3:::1;64058:257;;68279:78:::0;60974:12;:10;:12::i;:::-;60964:6;;-1:-1:-1;;;;;60964:6:0;;;:22;;;60956:67;;;;-1:-1:-1;;;60956:67:0;;;;;;;:::i;:::-;68329:12:::1;:20:::0;;-1:-1:-1;;;;68329:20:0::1;::::0;;68279:78::o;68021:117::-;60974:12;:10;:12::i;:::-;60964:6;;-1:-1:-1;;;;;60964:6:0;;;:22;;;60956:67;;;;-1:-1:-1;;;60956:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;68091:23:0::1;;::::0;;;:13:::1;:23;::::0;;;;:39;;-1:-1:-1;;68091:39:0::1;68126:4;68091:39;::::0;;68021:117::o;50374:156::-;-1:-1:-1;;;;;50487:25:0;;;50463:4;50487:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;50374:156::o;68948:113::-;60974:12;:10;:12::i;:::-;60964:6;;-1:-1:-1;;;;;60964:6:0;;;:22;;;60956:67;;;;-1:-1:-1;;;60956:67:0;;;;;;;:::i;:::-;69024:10:::1;::::0;69016:37:::1;::::0;-1:-1:-1;;;;;69024:10:0;;::::1;::::0;69016:37;::::1;;;::::0;69045:7;;69024:10:::1;69016:37:::0;69024:10;69016:37;69045:7;69024:10;69016:37;::::1;;;;;;;;;;;;;::::0;::::1;;;;61697:244:::0;60974:12;:10;:12::i;:::-;60964:6;;-1:-1:-1;;;;;60964:6:0;;;:22;;;60956:67;;;;-1:-1:-1;;;60956:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;61786:22:0;::::1;61778:73;;;;-1:-1:-1::0;;;61778:73:0::1;;;;;;;:::i;:::-;61888:6;::::0;61867:38:::1;::::0;-1:-1:-1;;;;;61867:38:0;;::::1;::::0;61888:6:::1;::::0;61867:38:::1;::::0;61888:6:::1;::::0;61867:38:::1;61916:6;:17:::0;;-1:-1:-1;;;;;;61916:17:0::1;-1:-1:-1::0;;;;;61916:17:0;;;::::1;::::0;;;::::1;::::0;;61697:244::o;68543:84::-;60974:12;:10;:12::i;:::-;60964:6;;-1:-1:-1;;;;;60964:6:0;;;:22;;;60956:67;;;;-1:-1:-1;;;60956:67:0;;;;;;;:::i;:::-;68596:15:::1;:23:::0;;-1:-1:-1;;;;68596:23:0::1;::::0;;68543:84::o;52947:119::-;53004:4;53028:30;:12;53050:7;53028:21;:30::i;643:106::-;731:10;643:106;:::o;58774:158::-;58840:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;58840:29:0;-1:-1:-1;;;;;58840:29:0;;;;;;;;:24;;58894:16;58840:24;58894:7;:16::i;:::-;-1:-1:-1;;;;;58885:39:0;;;;;;;;;;;58774:158;;:::o;57052:215::-;57152:16;57160:7;57152;:16::i;:::-;57144:73;;;;-1:-1:-1;;;57144:73:0;;;;;;;:::i;:::-;57228:19;;;;:10;:19;;;;;;;;:31;;;;;;;;:::i;40419:123::-;40488:7;40515:19;40523:3;40515:7;:19::i;53233:333::-;53318:4;53343:16;53351:7;53343;:16::i;:::-;53335:73;;;;-1:-1:-1;;;53335:73:0;;;;;;;:::i;:::-;53419:13;53435:16;53443:7;53435;:16::i;:::-;53419:32;;53481:5;-1:-1:-1;;;;;53470:16:0;:7;-1:-1:-1;;;;;53470:16:0;;:51;;;;53514:7;-1:-1:-1;;;;;53490:31:0;:20;53502:7;53490:11;:20::i;:::-;-1:-1:-1;;;;;53490:31:0;;53470:51;:87;;;;53525:32;53542:5;53549:7;53525:16;:32::i;:::-;53462:96;53233:333;-1:-1:-1;;;;53233:333:0:o;56322:574::-;56440:4;-1:-1:-1;;;;;56420:24:0;:16;56428:7;56420;:16::i;:::-;-1:-1:-1;;;;;56420:24:0;;56412:78;;;;-1:-1:-1;;;56412:78:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;56509:16:0;;56501:65;;;;-1:-1:-1;;;56501:65:0;;;;;;;:::i;:::-;56579:39;56600:4;56606:2;56610:7;56579:20;:39::i;:::-;56683:29;56700:1;56704:7;56683:8;:29::i;:::-;-1:-1:-1;;;;;56725:19:0;;;;;;:13;:19;;;;;:35;;56752:7;56725:26;:35::i;:::-;-1:-1:-1;;;;;;56771:17:0;;;;;;:13;:17;;;;;:30;;56793:7;56771:21;:30::i;:::-;-1:-1:-1;56814:29:0;:12;56831:7;56840:2;56814:16;:29::i;:::-;;56880:7;56876:2;-1:-1:-1;;;;;56861:27:0;56870:4;-1:-1:-1;;;;;56861:27:0;;;;;;;;;;;56322:574;;;:::o;13316:471::-;13374:7;13619:6;13615:47;;-1:-1:-1;13649:1:0;13642:8;;13615:47;13686:5;;;13690:1;13686;:5;:1;13710:5;;;;;:10;13702:56;;;;-1:-1:-1;;;13702:56:0;;;;;;;:::i;64331:502::-;64386:12;;64383:245;;64434:75;64441:1;62243:4;64489:12;:10;:12::i;:::-;-1:-1:-1;;;;;64465:39:0;64507:1;64465:43;64434:6;:75::i;:::-;64420:11;:89;;;64524:14;:28;64383:245;;;64599:17;:15;:17::i;:::-;64585:11;:31;64383:245;64638:12;:14;;;;;;;;64672:21;;:7;:21::i;:::-;64671:22;64663:67;;;;-1:-1:-1;;;64663:67:0;;;;;;;:::i;:::-;64741:24;64747:3;64752:12;;64741:5;:24::i;:::-;64776:49;64789:12;;64803:21;64812:11;;64803:8;:21::i;:::-;64776:12;:49::i;33005:137::-;33076:7;33111:22;33115:3;33127:5;33111:3;:22::i;55465:520::-;55525:13;55541:16;55549:7;55541;:16::i;:::-;55525:32;;55570:48;55591:5;55606:1;55610:7;55570:20;:48::i;:::-;55659:29;55676:1;55680:7;55659:8;:29::i;:::-;55747:19;;;;:10;:19;;;;;55741:33;;-1:-1:-1;;55741:33:0;;;;;;;;;;;:38;55737:97;;55803:19;;;;:10;:19;;;;;55796:26;;;:::i;:::-;-1:-1:-1;;;;;55846:20:0;;;;;;:13;:20;;;;;:36;;55874:7;55846:27;:36::i;:::-;-1:-1:-1;55895:28:0;:12;55915:7;55895:19;:28::i;:::-;-1:-1:-1;55941:36:0;;55969:7;;55965:1;;-1:-1:-1;;;;;55941:36:0;;;;;55965:1;;55941:36;55465:520;;:::o;40881:227::-;40961:7;;;;41021:22;41025:3;41037:5;41021:3;:22::i;:::-;40990:53;;;;-1:-1:-1;40881:227:0;-1:-1:-1;;;;;40881:227:0:o;57497:100::-;57570:19;;;;:8;;:19;;;;;:::i;41543:204::-;41650:7;41693:44;41698:3;41718;41724:12;41693:4;:44::i;15634:130::-;15692:7;15719:37;15723:1;15726;15719:37;;;;;;;;;;;;;;;;;:3;:37::i;52362:272::-;52476:28;52486:4;52492:2;52496:7;52476:9;:28::i;:::-;52523:48;52546:4;52552:2;52556:7;52565:5;52523:22;:48::i;:::-;52515:111;;;;-1:-1:-1;;;52515:111:0;;;;;;;:::i;12426:136::-;12484:7;12511:43;12515:1;12518;12511:43;;;;;;;;;;;;;;;;;:3;:43::i;42007:744::-;42063:13;42284:10;42280:53;;-1:-1:-1;42311:10:0;;;;;;;;;;;;-1:-1:-1;;;42311:10:0;;;;;;42280:53;42358:5;42343:12;42399:78;42406:9;;42399:78;;42432:8;;42463:2;42455:10;;;;42399:78;;;42487:19;42519:6;42509:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42509:17:0;-1:-1:-1;42581:5:0;;-1:-1:-1;42487:39:0;-1:-1:-1;;;42553:10:0;;42597:115;42604:9;;42597:115;;42671:2;42664:4;:9;42659:2;:14;42648:27;;42630:6;42637:7;;;;;;;42630:15;;;;;;;;;;;:45;-1:-1:-1;;;;;42630:45:0;;;;;;;;-1:-1:-1;42698:2:0;42690:10;;;;42597:115;;;-1:-1:-1;42736:6:0;42007:744;-1:-1:-1;;;;42007:744:0:o;40180:151::-;40264:4;40288:35;40298:3;40318;40288:9;:35::i;37802:110::-;37885:19;;37802:110::o;69313:177::-;69434:48;69461:5;69468:3;69473:8;69434:26;:48::i;32092:137::-;32162:4;32186:35;32194:3;32214:5;32186:7;:35::i;31785:131::-;31852:4;31876:32;31881:3;31901:5;31876:4;:32::i;39612:176::-;39701:4;39725:55;39730:3;39750;-1:-1:-1;;;;;39764:14:0;;39725:4;:55::i;54832:404::-;-1:-1:-1;;;;;54912:16:0;;54904:61;;;;-1:-1:-1;;;54904:61:0;;;;;;;:::i;:::-;54985:16;54993:7;54985;:16::i;:::-;54984:17;54976:58;;;;-1:-1:-1;;;54976:58:0;;;;;;;:::i;:::-;55047:45;55076:1;55080:2;55084:7;55047:20;:45::i;:::-;-1:-1:-1;;;;;55105:17:0;;;;;;:13;:17;;;;;:30;;55127:7;55105:21;:30::i;:::-;-1:-1:-1;55148:29:0;:12;55165:7;55174:2;55148:16;:29::i;:::-;-1:-1:-1;55195:33:0;;55220:7;;-1:-1:-1;;;;;55195:33:0;;;55212:1;;55195:33;;55212:1;;55195:33;54832:404;;:::o;64841:447::-;64893:27;64931:7;64927:35;;-1:-1:-1;64946:10:0;;;;;;;;;;;;-1:-1:-1;;;64946:10:0;;;;;;64927:35;64978:2;64966:9;65001:45;65008:6;;65001:45;;65022:5;;65038:2;65033:7;;;;65001:45;;;65050:17;65080:3;65070:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65070:14:0;-1:-1:-1;65050:34:0;-1:-1:-1;65101:3:0;65109:151;65116:7;;65109:151;;-1:-1:-1;;65135:5:0;65146:10;65182:2;65177;:7;65188:2;65176:14;65171:2;:19;65160:2;:31;65146:46;;65198:9;65217:4;65210:12;;65198:24;;65238:2;65228:4;65233:1;65228:7;;;;;;;;;;;:12;-1:-1:-1;;;;;65228:12:0;;;;;;;;-1:-1:-1;65252:2:0;65246:8;;;;65109:151;;;;28079:204;28174:18;;28146:7;;28174:26;-1:-1:-1;28166:73:0;;;;-1:-1:-1;;;28166:73:0;;;;;;;:::i;:::-;28257:3;:11;;28269:5;28257:18;;;;;;;;;;;;;;;;28250:25;;28079:204;;;;:::o;39954:142::-;40031:4;40055:33;40063:3;40083;40055:7;:33::i;38267:279::-;38371:19;;38334:7;;;;38371:27;-1:-1:-1;38363:74:0;;;;-1:-1:-1;;;38363:74:0;;;;;;;:::i;:::-;38450:22;38475:3;:12;;38488:5;38475:19;;;;;;;;;;;;;;;;;;38450:44;;38513:5;:10;;;38525:5;:12;;;38505:33;;;;;38267:279;;;;;:::o;38969:319::-;39063:7;39102:17;;;:12;;;:17;;;;;;39153:12;39138:13;39130:36;;;;-1:-1:-1;;;39130:36:0;;;;;;;;:::i;:::-;;39220:3;:12;;39244:1;39233:8;:12;39220:26;;;;;;;;;;;;;;;;;;:33;;;39213:40;;;38969:319;;;;;:::o;16249:166::-;16335:7;16371:12;16363:6;16355:29;;;;-1:-1:-1;;;16355:29:0;;;;;;;;:::i;:::-;;16406:1;16402;:5;;;;;;;16249:166;-1:-1:-1;;;;16249:166:0:o;58162:604::-;58283:4;58310:15;:2;-1:-1:-1;;;;;58310:13:0;;:15::i;:::-;58305:60;;-1:-1:-1;58349:4:0;58342:11;;58305:60;58375:23;58401:252;-1:-1:-1;;;58514:12:0;:10;:12::i;:::-;58541:4;58560:7;58582:5;58417:181;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;58417:181:0;;;;;;;-1:-1:-1;;;;;58417:181:0;;;;;;;;;;;58401:252;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;58401:15:0;;;:252;:15;:252::i;:::-;58375:278;;58664:13;58691:10;58680:32;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;58731:26:0;-1:-1:-1;;;58731:26:0;;-1:-1:-1;;;58162:604:0;;;;;;:::o;12865:192::-;12951:7;12987:12;12979:6;;;;12971:29;;;;-1:-1:-1;;;12971:29:0;;;;;;;;:::i;:::-;-1:-1:-1;;;13023:5:0;;;12865:192::o;37582:125::-;37653:4;37677:17;;;:12;;;;;:17;;;;;;:22;;;37582:125::o;25781:1544::-;25847:4;25986:19;;;:12;;;:19;;;;;;26022:15;;26018:1300;;26457:18;;-1:-1:-1;;26408:14:0;;;;26457:22;;;;26384:21;;26457:3;;:22;;26744;;;;;;;;;;;;;;26724:42;;26890:9;26861:3;:11;;26873:13;26861:26;;;;;;;;;;;;;;;;;;;:38;;;;26967:23;;;27009:1;26967:12;;;:23;;;;;;26993:17;;;26967:43;;27119:17;;26967:3;;27119:17;;;;;;;;;;;;;;;;;;;;;;27214:3;:12;;:19;27227:5;27214:19;;;;;;;;;;;27207:26;;;27257:4;27250:11;;;;;;;;26018:1300;27301:5;27294:12;;;;;25191:414;25254:4;25276:21;25286:3;25291:5;25276:9;:21::i;:::-;25271:327;;-1:-1:-1;25314:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;25497:18;;25475:19;;;:12;;;:19;;;;;;:40;;;;25530:11;;25271:327;-1:-1:-1;25581:5:0;25574:12;;35082:692;35158:4;35293:17;;;:12;;;:17;;;;;;35327:13;35323:444;;-1:-1:-1;;35412:38:0;;;;;;;;;;;;;;;;;;35394:57;;;;;;;;:12;:57;;;;;;;;;;;;;;;;;;;;;;;;35609:19;;35589:17;;;:12;;;:17;;;;;;;:39;35643:11;;35323:444;35723:5;35687:3;:12;;35711:1;35700:8;:12;35687:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;35750:5;35743:12;;;;;35949:1549;36013:4;36148:17;;;:12;;;:17;;;;;;36182:13;;36178:1313;;36614:19;;-1:-1:-1;;36567:12:0;;;;36614:23;;;;36543:21;;36614:3;;:23;;36911;;;;;;;;;;;;;;;;36882:52;;37059:9;37029:3;:12;;37042:13;37029:27;;;;;;;;;;;;;;;;:39;;:27;;;;;:39;;;;;;;;;;;;;;;37149:14;;37136:28;;:12;;;:28;;;;;37167:17;;;37136:48;;37293:18;;37136:3;;37293:18;;;;;;;;;;;;;;-1:-1:-1;;37293:18:0;;;;;;;;;;;;;;;;;;;;;37389:17;;;:12;;;:17;;;;;;37382:24;;;;37293:18;-1:-1:-1;37423:11:0;;-1:-1:-1;;;;37423:11:0;17205:422;17572:20;17611:8;;;17205:422::o;20123:195::-;20226:12;20258:52;20280:6;20288:4;20294:1;20297:12;20226;21427:18;21438:6;21427:10;:18::i;:::-;21419:60;;;;-1:-1:-1;;;21419:60:0;;;;;;;:::i;:::-;21553:12;21567:23;21594:6;-1:-1:-1;;;;;21594:11:0;21614:5;21622:4;21594:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21552:75;;;;21645:52;21663:7;21672:10;21684:12;21645:17;:52::i;:::-;21638:59;21175:530;-1:-1:-1;;;;;;;21175:530:0:o;22711:742::-;22826:12;22855:7;22851:595;;;-1:-1:-1;22886:10:0;22879:17;;22851:595;23000:17;;:21;22996:439;;23263:10;23257:17;23324:15;23311:10;23307:2;23303:19;23296:44;23211:148;23406:12;23399:20;;-1:-1:-1;;;23399:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:400:1;;114:18;106:6;103:30;100:2;;;136:9;100:2;165:58;211:2;188:17;;-1:-1:-1;;184:31:1;217:4;180:42;165:58;:::i;:::-;156:67;;246:6;239:5;232:21;286:3;277:6;272:3;268:16;265:25;262:2;;;303:1;300;293:12;262:2;352:6;347:3;340:4;333:5;329:16;316:43;406:1;399:4;390:6;383:5;379:18;375:29;368:40;90:324;;;;;:::o;419:175::-;489:20;;-1:-1:-1;;;;;538:31:1;;528:42;;518:2;;584:1;581;574:12;599:233;;697:3;690:4;682:6;678:17;674:27;664:2;;719:5;712;705:20;664:2;745:81;822:3;813:6;800:20;793:4;785:6;781:17;745:81;:::i;837:198::-;;949:2;937:9;928:7;924:23;920:32;917:2;;;970:6;962;955:22;917:2;998:31;1019:9;998:31;:::i;1040:274::-;;;1169:2;1157:9;1148:7;1144:23;1140:32;1137:2;;;1190:6;1182;1175:22;1137:2;1218:31;1239:9;1218:31;:::i;:::-;1208:41;;1268:40;1304:2;1293:9;1289:18;1268:40;:::i;:::-;1258:50;;1127:187;;;;;:::o;1319:342::-;;;;1465:2;1453:9;1444:7;1440:23;1436:32;1433:2;;;1486:6;1478;1471:22;1433:2;1514:31;1535:9;1514:31;:::i;:::-;1504:41;;1564:40;1600:2;1589:9;1585:18;1564:40;:::i;:::-;1554:50;;1651:2;1640:9;1636:18;1623:32;1613:42;;1423:238;;;;;:::o;1666:702::-;;;;;1838:3;1826:9;1817:7;1813:23;1809:33;1806:2;;;1860:6;1852;1845:22;1806:2;1888:31;1909:9;1888:31;:::i;:::-;1878:41;;1938:40;1974:2;1963:9;1959:18;1938:40;:::i;:::-;1928:50;;2025:2;2014:9;2010:18;1997:32;1987:42;;2080:2;2069:9;2065:18;2052:32;2107:18;2099:6;2096:30;2093:2;;;2144:6;2136;2129:22;2093:2;2172:22;;2225:4;2217:13;;2213:27;-1:-1:-1;2203:2:1;;2259:6;2251;2244:22;2203:2;2287:75;2354:7;2349:2;2336:16;2331:2;2327;2323:11;2287:75;:::i;:::-;2277:85;;;1796:572;;;;;;;:::o;2373:369::-;;;2499:2;2487:9;2478:7;2474:23;2470:32;2467:2;;;2520:6;2512;2505:22;2467:2;2548:31;2569:9;2548:31;:::i;:::-;2538:41;;2629:2;2618:9;2614:18;2601:32;2676:5;2669:13;2662:21;2655:5;2652:32;2642:2;;2703:6;2695;2688:22;2642:2;2731:5;2721:15;;;2457:285;;;;;:::o;2747:266::-;;;2876:2;2864:9;2855:7;2851:23;2847:32;2844:2;;;2897:6;2889;2882:22;2844:2;2925:31;2946:9;2925:31;:::i;:::-;2915:41;3003:2;2988:18;;;;2975:32;;-1:-1:-1;;;2834:179:1:o;3018:1001::-;;3133:2;3176;3164:9;3155:7;3151:23;3147:32;3144:2;;;3197:6;3189;3182:22;3144:2;3242:9;3229:23;3271:18;3312:2;3304:6;3301:14;3298:2;;;3333:6;3325;3318:22;3298:2;3376:6;3365:9;3361:22;3351:32;;3421:7;3414:4;3410:2;3406:13;3402:27;3392:2;;3448:6;3440;3433:22;3392:2;3489;3476:16;3511:2;3507;3504:10;3501:2;;;3517:9;3501:2;3555;3551;3547:11;3537:21;;3578:27;3601:2;3597;3593:11;3578:27;:::i;:::-;3639:15;;;3670:12;;;;3702:11;;;3732;;;3728:20;;3725:33;-1:-1:-1;3722:2:1;;;3776:6;3768;3761:22;3722:2;3803:6;3794:15;;3818:171;3832:2;3829:1;3826:9;3818:171;;;3889:25;3910:3;3889:25;:::i;:::-;3877:38;;3850:1;3843:9;;;;;3935:12;;;;3967;;3818:171;;;-1:-1:-1;4008:5:1;3113:906;-1:-1:-1;;;;;;;;3113:906:1:o;4024:257::-;;4135:2;4123:9;4114:7;4110:23;4106:32;4103:2;;;4156:6;4148;4141:22;4103:2;4200:9;4187:23;4219:32;4245:5;4219:32;:::i;4286:261::-;;4408:2;4396:9;4387:7;4383:23;4379:32;4376:2;;;4429:6;4421;4414:22;4376:2;4466:9;4460:16;4485:32;4511:5;4485:32;:::i;4552:344::-;;4674:2;4662:9;4653:7;4649:23;4645:32;4642:2;;;4695:6;4687;4680:22;4642:2;4740:9;4727:23;4773:18;4765:6;4762:30;4759:2;;;4810:6;4802;4795:22;4759:2;4838:52;4882:7;4873:6;4862:9;4858:22;4838:52;:::i;4901:190::-;;5013:2;5001:9;4992:7;4988:23;4984:32;4981:2;;;5034:6;5026;5019:22;4981:2;-1:-1:-1;5062:23:1;;4971:120;-1:-1:-1;4971:120:1:o;5096:412::-;;;5235:2;5223:9;5214:7;5210:23;5206:32;5203:2;;;5256:6;5248;5241:22;5203:2;5297:9;5284:23;5274:33;;5358:2;5347:9;5343:18;5330:32;5385:18;5377:6;5374:30;5371:2;;;5422:6;5414;5407:22;5371:2;5450:52;5494:7;5485:6;5474:9;5470:22;5450:52;:::i;:::-;5440:62;;;5193:315;;;;;:::o;5513:326::-;;;;5659:2;5647:9;5638:7;5634:23;5630:32;5627:2;;;5680:6;5672;5665:22;5627:2;-1:-1:-1;;5708:23:1;;;5778:2;5763:18;;5750:32;;-1:-1:-1;5829:2:1;5814:18;;;5801:32;;5617:222;-1:-1:-1;5617:222:1:o;5844:259::-;;5925:5;5919:12;5952:6;5947:3;5940:19;5968:63;6024:6;6017:4;6012:3;6008:14;6001:4;5994:5;5990:16;5968:63;:::i;:::-;6085:2;6064:15;-1:-1:-1;;6060:29:1;6051:39;;;;6092:4;6047:50;;5895:208;-1:-1:-1;;5895:208:1:o;6108:245::-;6273:2;6269:15;;;;-1:-1:-1;;6265:53:1;6253:66;;6344:2;6335:12;;6243:110::o;6358:274::-;;6525:6;6519:13;6541:53;6587:6;6582:3;6575:4;6567:6;6563:17;6541:53;:::i;:::-;6610:16;;;;;6495:137;-1:-1:-1;;6495:137:1:o;6637:993::-;;6842:3;6877:6;6871:13;6903:1;6935:2;6924:9;6920:18;6952:1;6947:126;;;;7087:1;7082:406;;;;6913:575;;6947:126;-1:-1:-1;;6980:24:1;;6968:37;;7053:1;7038:17;;7057:4;7034:28;7025:38;;;-1:-1:-1;6947:126:1;;7082:406;7132:1;7121:9;7117:17;7159:6;7154:3;7147:19;7189:4;7236:2;7231:3;7221:18;7261:3;7277:165;7291:6;7288:1;7285:13;7277:165;;;7369:14;;7356:11;;;7349:35;7412:16;;;;7306:10;;7277:165;;;-1:-1:-1;;;7462:16:1;;;-1:-1:-1;6913:575:1;;;;7519:6;7513:13;7535:55;7581:8;7576:3;7569:4;7561:6;7557:17;7535:55;:::i;:::-;7606:18;;6821:809;-1:-1:-1;;;;6821:809:1:o;7635:182::-;7764:19;;;7808:2;7799:12;;7754:63::o;7822:203::-;-1:-1:-1;;;;;7986:32:1;;;;7968:51;;7956:2;7941:18;;7923:102::o;8030:506::-;-1:-1:-1;;;;;8315:15:1;;;8297:34;;8367:15;;8362:2;8347:18;;8340:43;8414:2;8399:18;;8392:34;;;8462:3;8457:2;8442:18;;8435:31;;;8030:506;;8483:47;;8510:19;;8502:6;8483:47;:::i;:::-;8475:55;8249:287;-1:-1:-1;;;;;;8249:287:1:o;8541:187::-;8706:14;;8699:22;8681:41;;8669:2;8654:18;;8636:92::o;8733:258::-;8926:14;;8919:22;8901:41;;8973:2;8958:18;;8951:34;8889:2;8874:18;;8856:135::o;8996:221::-;;9145:2;9134:9;9127:21;9165:46;9207:2;9196:9;9192:18;9184:6;9165:46;:::i;9222:398::-;9424:2;9406:21;;;9463:2;9443:18;;;9436:30;9502:34;9497:2;9482:18;;9475:62;-1:-1:-1;;;9568:2:1;9553:18;;9546:32;9610:3;9595:19;;9396:224::o;9625:410::-;9827:2;9809:21;;;9866:2;9846:18;;;9839:30;9905:34;9900:2;9885:18;;9878:62;-1:-1:-1;;;9971:2:1;9956:18;;9949:44;10025:3;10010:19;;9799:236::o;10040:414::-;10242:2;10224:21;;;10281:2;10261:18;;;10254:30;10320:34;10315:2;10300:18;;10293:62;-1:-1:-1;;;10386:2:1;10371:18;;10364:48;10444:3;10429:19;;10214:240::o;10459:408::-;10661:2;10643:21;;;10700:2;10680:18;;;10673:30;10739:34;10734:2;10719:18;;10712:62;-1:-1:-1;;;10805:2:1;10790:18;;10783:42;10857:3;10842:19;;10633:234::o;10872:402::-;11074:2;11056:21;;;11113:2;11093:18;;;11086:30;11152:34;11147:2;11132:18;;11125:62;-1:-1:-1;;;11218:2:1;11203:18;;11196:36;11264:3;11249:19;;11046:228::o;11279:352::-;11481:2;11463:21;;;11520:2;11500:18;;;11493:30;11559;11554:2;11539:18;;11532:58;11622:2;11607:18;;11453:178::o;11636:401::-;11838:2;11820:21;;;11877:2;11857:18;;;11850:30;11916:34;11911:2;11896:18;;11889:62;-1:-1:-1;;;11982:2:1;11967:18;;11960:35;12027:3;12012:19;;11810:227::o;12042:423::-;12244:2;12226:21;;;12283:2;12263:18;;;12256:30;12322:34;12317:2;12302:18;;12295:62;12393:29;12388:2;12373:18;;12366:57;12455:3;12440:19;;12216:249::o;12470:400::-;12672:2;12654:21;;;12711:2;12691:18;;;12684:30;12750:34;12745:2;12730:18;;12723:62;-1:-1:-1;;;12816:2:1;12801:18;;12794:34;12860:3;12845:19;;12644:226::o;12875:349::-;13077:2;13059:21;;;13116:2;13096:18;;;13089:30;13155:27;13150:2;13135:18;;13128:55;13215:2;13200:18;;13049:175::o;13229:397::-;13431:2;13413:21;;;13470:2;13450:18;;;13443:30;13509:34;13504:2;13489:18;;13482:62;-1:-1:-1;;;13575:2:1;13560:18;;13553:31;13616:3;13601:19;;13403:223::o;13631:416::-;13833:2;13815:21;;;13872:2;13852:18;;;13845:30;13911:34;13906:2;13891:18;;13884:62;-1:-1:-1;;;13977:2:1;13962:18;;13955:50;14037:3;14022:19;;13805:242::o;14459:408::-;14661:2;14643:21;;;14700:2;14680:18;;;14673:30;14739:34;14734:2;14719:18;;14712:62;-1:-1:-1;;;14805:2:1;14790:18;;14783:42;14857:3;14842:19;;14633:234::o;14872:403::-;15074:2;15056:21;;;15113:2;15093:18;;;15086:30;15152:34;15147:2;15132:18;;15125:62;-1:-1:-1;;;15218:2:1;15203:18;;15196:37;15265:3;15250:19;;15046:229::o;15280:420::-;15482:2;15464:21;;;15521:2;15501:18;;;15494:30;15560:34;15555:2;15540:18;;15533:62;15631:26;15626:2;15611:18;;15604:54;15690:3;15675:19;;15454:246::o;15705:406::-;15907:2;15889:21;;;15946:2;15926:18;;;15919:30;15985:34;15980:2;15965:18;;15958:62;-1:-1:-1;;;16051:2:1;16036:18;;16029:40;16101:3;16086:19;;15879:232::o;16116:398::-;16318:2;16300:21;;;16357:2;16337:18;;;16330:30;16396:34;16391:2;16376:18;;16369:62;-1:-1:-1;;;16462:2:1;16447:18;;16440:32;16504:3;16489:19;;16290:224::o;16519:356::-;16721:2;16703:21;;;16740:18;;;16733:30;16799:34;16794:2;16779:18;;16772:62;16866:2;16851:18;;16693:182::o;16880:356::-;17082:2;17064:21;;;17101:18;;;17094:30;17160:34;17155:2;17140:18;;17133:62;17227:2;17212:18;;17054:182::o;17241:397::-;17443:2;17425:21;;;17482:2;17462:18;;;17455:30;17521:34;17516:2;17501:18;;17494:62;-1:-1:-1;;;17587:2:1;17572:18;;17565:31;17628:3;17613:19;;17415:223::o;17643:408::-;17845:2;17827:21;;;17884:2;17864:18;;;17857:30;17923:34;17918:2;17903:18;;17896:62;-1:-1:-1;;;17989:2:1;17974:18;;17967:42;18041:3;18026:19;;17817:234::o;18056:408::-;18258:2;18240:21;;;18297:2;18277:18;;;18270:30;18336:34;18331:2;18316:18;;18309:62;-1:-1:-1;;;18402:2:1;18387:18;;18380:42;18454:3;18439:19;;18230:234::o;18469:356::-;18671:2;18653:21;;;18690:18;;;18683:30;18749:34;18744:2;18729:18;;18722:62;18816:2;18801:18;;18643:182::o;18830:405::-;19032:2;19014:21;;;19071:2;19051:18;;;19044:30;19110:34;19105:2;19090:18;;19083:62;-1:-1:-1;;;19176:2:1;19161:18;;19154:39;19225:3;19210:19;;19004:231::o;19240:411::-;19442:2;19424:21;;;19481:2;19461:18;;;19454:30;19520:34;19515:2;19500:18;;19493:62;-1:-1:-1;;;19586:2:1;19571:18;;19564:45;19641:3;19626:19;;19414:237::o;19656:400::-;19858:2;19840:21;;;19897:2;19877:18;;;19870:30;19936:34;19931:2;19916:18;;19909:62;-1:-1:-1;;;20002:2:1;19987:18;;19980:34;20046:3;20031:19;;19830:226::o;20061:397::-;20263:2;20245:21;;;20302:2;20282:18;;;20275:30;20341:34;20336:2;20321:18;;20314:62;-1:-1:-1;;;20407:2:1;20392:18;;20385:31;20448:3;20433:19;;20235:223::o;20463:354::-;20665:2;20647:21;;;20704:2;20684:18;;;20677:30;20743:32;20738:2;20723:18;;20716:60;20808:2;20793:18;;20637:180::o;20822:397::-;21024:2;21006:21;;;21063:2;21043:18;;;21036:30;21102:34;21097:2;21082:18;;21075:62;-1:-1:-1;;;21168:2:1;21153:18;;21146:31;21209:3;21194:19;;20996:223::o;21224:397::-;21426:2;21408:21;;;21465:2;21445:18;;;21438:30;21504:34;21499:2;21484:18;;21477:62;-1:-1:-1;;;21570:2:1;21555:18;;21548:31;21611:3;21596:19;;21398:223::o;21626:422::-;21828:2;21810:21;;;21867:2;21847:18;;;21840:30;21906:34;21901:2;21886:18;;21879:62;21977:28;21972:2;21957:18;;21950:56;22038:3;22023:19;;21800:248::o;22053:413::-;22255:2;22237:21;;;22294:2;22274:18;;;22267:30;22333:34;22328:2;22313:18;;22306:62;-1:-1:-1;;;22399:2:1;22384:18;;22377:47;22456:3;22441:19;;22227:239::o;22471:353::-;22673:2;22655:21;;;22712:2;22692:18;;;22685:30;22751:31;22746:2;22731:18;;22724:59;22815:2;22800:18;;22645:179::o;22829:397::-;23031:2;23013:21;;;23070:2;23050:18;;;23043:30;23109:34;23104:2;23089:18;;23082:62;-1:-1:-1;;;23175:2:1;23160:18;;23153:31;23216:3;23201:19;;23003:223::o;23413:242::-;23483:2;23477:9;23513:17;;;23560:18;23545:34;;23581:22;;;23542:62;23539:2;;;23607:9;23539:2;23634;23627:22;23457:198;;-1:-1:-1;23457:198:1:o;23660:258::-;23732:1;23742:113;23756:6;23753:1;23750:13;23742:113;;;23832:11;;;23826:18;23813:11;;;23806:39;23778:2;23771:10;23742:113;;;23873:6;23870:1;23867:13;23864:2;;;-1:-1:-1;;23908:1:1;23890:16;;23883:27;23713:205::o;23923:133::-;-1:-1:-1;;;;;;23999:32:1;;23989:43;;23979:2;;24046:1;24043;24036:12

Swarm Source

ipfs://f2b10f79e24ddadaa523027d6c25b4c492dc40d61a24c8fd439dbdf1200cce62

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