Token

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import "./Power.sol";

// File @openzeppelin/contracts/introspection/[email protected]

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

// File @openzeppelin/contracts/token/ERC721/[email protected]

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

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

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

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

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

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

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

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

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

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

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

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

// File @openzeppelin/contracts/token/ERC721/[email protected]

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

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

// File @openzeppelin/contracts/token/ERC721/[email protected]

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

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

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

// File @openzeppelin/contracts/token/ERC721/[email protected]

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

/**
 * @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
        virtual
        override
        returns (bool)
    {
        return _supportedInterfaces[interfaceId];
    }

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

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(
            address(this).balance >= amount,
            "Address: insufficient balance"
        );

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{value: amount}("");
        require(
            success,
            "Address: unable to send value, recipient may have reverted"
        );
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                value,
                "Address: low-level call with value failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(
            address(this).balance >= value,
            "Address: insufficient balance for call"
        );
        require(isContract(target), "Address: call to non-contract");

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data)
        internal
        view
        returns (bytes memory)
    {
        return
            functionStaticCall(
                target,
                data,
                "Address: low-level static call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return
            functionDelegateCall(
                target,
                data,
                "Address: low-level delegate call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

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

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

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

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

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

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

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

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

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

            bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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

    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

    struct Map {
        // Storage of map keys and values
        MapEntry[] _entries;
        // Position of the entry defined by a key in the `entries` array, plus 1
        // because index 0 means a key is not in the map.
        mapping(bytes32 => uint256) _indexes;
    }

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

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

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

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

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

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

            MapEntry storage lastEntry = map._entries[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

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

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

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

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

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

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

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

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

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

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

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

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

/**
 * @dev String operations.
 */
library Strings {
    /**
     * @dev Converts a `uint256` to its ASCII `string` representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        uint256 index = digits - 1;
        temp = value;
        while (temp != 0) {
            buffer[index--] = bytes1(uint8(48 + (temp % 10)));
            temp /= 10;
        }
        return string(buffer);
    }
}

/**
 * @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
        virtual
        override
        returns (uint256)
    {
        require(
            owner != address(0),
            "MetaV: balance query for the zero address"
        );
        return _holderTokens[owner].length();
    }

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

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

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

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

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = baseURI();

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

    function uint2str(uint256 _i) internal pure returns (string memory str) {
        if (_i == 0) {
            return "0";
        }
        uint256 j = _i;
        uint256 length;
        while (j != 0) {
            length++;
            j /= 10;
        }
        bytes memory bstr = new bytes(length);
        uint256 k = length;
        j = _i;
        while (j != 0) {
            bstr[--k] = bytes1(uint8(48 + (j % 10)));
            j /= 10;
        }
        str = string(bstr);
    }

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved)
        public
        virtual
        override
    {
        require(operator != _msgSender(), "MetaV: approve to caller");

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "MetaV: 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),
            "MetaV: 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),
            "MetaV: transfer to non ERC721Receiver implementer"
        );
    }

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

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

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

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "MetaV: 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), "MetaV: mint to the zero address");
        require(!_exists(tokenId), "MetaV: token already minted");

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

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

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

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

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

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

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

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(tokenId);

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

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

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

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

contract MetaVCollection is ERC721, Power {
    // ( Serial Id ) => ( Next Mint Id )
    mapping(uint256 => uint256) private _mintIds;

    // ( Serial Id ) => ( TotalSupply )
    mapping(uint256 => uint256) private _totalCaps;

    constructor(
        string memory name,
        string memory symbol,
        string memory _defaultTokenURI
    ) public ERC721(name, symbol) {
        _setBaseURI(_defaultTokenURI);
    }

    function addSerial(
        uint256 serialId,
        uint256 baseId,
        uint256 totalCount
    ) public isPowerful {
        setSerialNextId(serialId, baseId);
        setTotalSupply(serialId, baseId + totalCount);
    }

    function setSerialNextId(uint256 serialId, uint256 baseId)
        public
        isPowerful
    {
        _mintIds[serialId] = baseId;
    }

    function getSerialNextId(uint256 serialId) public returns (uint256) {
        return _mintIds[serialId];
    }

    function setTotalSupply(uint256 serialId, uint256 _totalSupply)
        public
        isPowerful
    {
        _totalCaps[serialId] = _totalSupply;
    }

    function getTotalSupply(uint256 serialId) public returns (uint256) {
        return _totalCaps[serialId];
    }

    function mint(uint256 serialId, address user) public isPowerful {
        require(_mintIds[serialId] > 0, "MetaV: Invalid serial id");
        require(
            _mintIds[serialId] <= _totalCaps[serialId],
            "MetaV: Exceed the supply limit"
        );
        _mint(user, _mintIds[serialId]++);
    }

    function multiMint(
        uint256 serialId,
        address user,
        uint256 count
    ) public isPowerful {
        require(count <= 10, "MetaV: Too much one time");
        for (uint256 i = 0; i < count; i++) {
            mint(serialId, user);
        }
    }
}

// contract MetaVMarket is ReentrancyGuard, Ownable {
//     using EnumerableSet for EnumerableSet.AddressSet;

//     mapping(uint256 => address) private _collectionSerials;
//     mapping(uint256 => uint256) private _serialPrices;
//     mapping(uint256 => uint256) private _presalePrices;
//     mapping(uint256 => uint256) private _biggerVoucher;
//     mapping(uint256 => address) public luckyDog;

//     EnumerableSet.AddressSet private whiteList;
//     uint256 presaleEndBlock;

//     constructor() public {
//         presaleEndBlock = block.number;
//     }

//     function purchase(uint256 serialId, uint256 count)
//         external
//         payable
//         nonReentrant
//         onlyEOA
//     {
//         require(count > 0 && count <= 100, "MetaV: Invalid count");
//         uint256 price = _serialPrices[serialId];

//         if (block.number < presaleEndBlock) {
//             require(whiteList.contains(msg.sender), "");
//             price = _presalePrices[serialId];
//         }

//         require(
//             msg.value >= price * count,
//             "MetaV: Insufficient ether to purchase"
//         );
//         address token = _collectionSerials[serialId];

//         for (uint256 i = 0; i < count; i++) {
//             MetaVCollection(token).deliver(_msgSender());
//         }

//         uint256 currVoucher = voucher();
//         if (_biggerVoucher[serialId] < currVoucher) {
//             _biggerVoucher[serialId] = currVoucher;
//             luckyDog[serialId] = _msgSender();
//         }
//     }

//     function preMint(
//         uint256 serialId,
//         address _to,
//         uint256 count
//     ) external payable nonReentrant onlyOwner {
//         address token = _collectionSerials[serialId];
//         for (uint256 i = 0; i < count; i++) {
//             MetaVCollection(token).deliver(serialId, _to);
//         }
//     }

//     function returnOwnership(uint256 serialId, address newOwner) external {
//         address token = _collectionSerials[serialId];
//         Ownable(token).transferOwnership(newOwner);
//     }

//     function setPresaleBlock(uint256 _block) external onlyOwner {
//         presaleEndBlock = _block;
//     }

//     function addWhiteList(address[] memory addrs) external onlyOwner {
//         for (uint256 i = 0; i < addrs.length; i++) {
//             whiteList.add(addrs[i]);
//         }
//     }

//     function addSerial(
//         uint256 serialId,
//         address tokenAddr,
//         uint256 price,
//         uint256 presalePrice
//     ) external nonReentrant onlyOwner {
//         _collectionSerials[serialId] = tokenAddr;
//         _serialPrices[serialId] = price;
//         _presalePrices[serialId] = presalePrice;
//     }

//     modifier onlyEOA() {
//         require(msg.sender == tx.origin, "Illegal caller");
//         _;
//     }

//     function voucher() internal view returns (uint256 value) {
//         bytes memory bs = abi.encodePacked(msg.sender);
//         bytes memory st = slice(bs, 4, 8);
//         assembly {
//             value := mload(add(st, 0x20))
//         }
//     }

//     function withdraw(address payable checker) external onlyOwner {
//         checker.transfer(address(this).balance);
//     }

//     function slice(
//         bytes memory _bytes,
//         uint256 _start,
//         uint256 _length
//     ) internal pure returns (bytes memory) {
//         require(_length + 31 >= _length, "slice_overflow");
//         require(_bytes.length >= _start + _length, "slice_outOfBounds");

//         bytes memory tempBytes;

//         assembly {
//             switch iszero(_length)
//             case 0 {
//                 // Get a location of some free memory and store it in tempBytes as
//                 // Solidity does for memory variables.
//                 tempBytes := mload(0x40)

//                 // The first word of the slice result is potentially a partial
//                 // word read from the original array. To read it, we calculate
//                 // the length of that partial word and start copying that many
//                 // bytes into the array. The first word we copy will start with
//                 // data we don't care about, but the last `lengthmod` bytes will
//                 // land at the beginning of the contents of the new array. When
//                 // we're done copying, we overwrite the full first word with
//                 // the actual length of the slice.
//                 let lengthmod := and(_length, 31)

//                 // The multiplication in the next line is necessary
//                 // because when slicing multiples of 32 bytes (lengthmod == 0)
//                 // the following copy loop was copying the origin's length
//                 // and then ending prematurely not copying everything it should.
//                 let mc := add(
//                     add(tempBytes, lengthmod),
//                     mul(0x20, iszero(lengthmod))
//                 )
//                 let end := add(mc, _length)

//                 for {
//                     // The multiplication in the next line has the same exact purpose
//                     // as the one above.
//                     let cc := add(
//                         add(
//                             add(_bytes, lengthmod),
//                             mul(0x20, iszero(lengthmod))
//                         ),
//                         _start
//                     )
//                 } lt(mc, end) {
//                     mc := add(mc, 0x20)
//                     cc := add(cc, 0x20)
//                 } {
//                     mstore(mc, mload(cc))
//                 }

//                 mstore(tempBytes, _length)

//                 //update free-memory pointer
//                 //allocating the array padded to 32 bytes like the compiler does now
//                 mstore(0x40, and(add(mc, 31), not(31)))
//             }
//             //if we want a zero-length slice let's just return a zero-length array
//             default {
//                 tempBytes := mload(0x40)
//                 //zero out the 32 bytes slice we are about to return
//                 //we need to do it because Solidity does not garbage collect
//                 mstore(tempBytes, 0)

//                 mstore(0x40, add(tempBytes, 0x20))
//             }
//         }

//         return tempBytes;
//     }
// }

/// [MIT License]
/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <[email protected]>
library Base64 {
    bytes internal constant TABLE =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    /// @notice Encodes some bytes to the base64 representation
    function encode(bytes memory data) internal pure returns (string memory) {
        uint256 len = data.length;
        if (len == 0) return "";

        // multiply by 4/3 rounded up
        uint256 encodedLen = 4 * ((len + 2) / 3);

        // Add some extra buffer at the end
        bytes memory result = new bytes(encodedLen + 32);

        bytes memory table = TABLE;

        assembly {
            let tablePtr := add(table, 1)
            let resultPtr := add(result, 32)

            for {
                let i := 0
            } lt(i, len) {

            } {
                i := add(i, 3)
                let input := and(mload(add(data, i)), 0xffffff)

                let out := mload(add(tablePtr, and(shr(18, input), 0x3F)))
                out := shl(8, out)
                out := add(
                    out,
                    and(mload(add(tablePtr, and(shr(12, input), 0x3F))), 0xFF)
                )
                out := shl(8, out)
                out := add(
                    out,
                    and(mload(add(tablePtr, and(shr(6, input), 0x3F))), 0xFF)
                )
                out := shl(8, out)
                out := add(
                    out,
                    and(mload(add(tablePtr, and(input, 0x3F))), 0xFF)
                )
                out := shl(224, out)

                mstore(resultPtr, out)

                resultPtr := add(resultPtr, 4)
            }

            switch mod(len, 3)
            case 1 {
                mstore(sub(resultPtr, 2), shl(240, 0x3d3d))
            }
            case 2 {
                mstore(sub(resultPtr, 1), shl(248, 0x3d))
            }

            mstore(result, encodedLen)
        }

        return string(result);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^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 meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Context.sol";

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

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

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

import "./Ownable.sol";

contract Power is Ownable {
    mapping(address => uint256) internal _powerOnes;

    constructor() public {
        _powerOnes[msg.sender] = 1;
    }

    modifier isPowerful() {
        require(_powerOnes[msg.sender] > 0, "Power: Insufficient power");
        _;
    }

    function addOne(address oneAddr) public onlyOwner {
        _powerOnes[oneAddr] = 1;
    }

    function removeOne(address oneAddr) public onlyOwner {
        require(oneAddr != owner(), "Trying to slay a god");
        delete _powerOnes[oneAddr];
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"string","name":"_defaultTokenURI","type":"string"}],"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":[{"internalType":"address","name":"oneAddr","type":"address"}],"name":"addOne","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"serialId","type":"uint256"},{"internalType":"uint256","name":"baseId","type":"uint256"},{"internalType":"uint256","name":"totalCount","type":"uint256"}],"name":"addSerial","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":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"serialId","type":"uint256"}],"name":"getSerialNextId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"serialId","type":"uint256"}],"name":"getTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","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":"uint256","name":"serialId","type":"uint256"},{"internalType":"address","name":"user","type":"address"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"serialId","type":"uint256"},{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"count","type":"uint256"}],"name":"multiMint","outputs":[],"stateMutability":"nonpayable","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":"address","name":"oneAddr","type":"address"}],"name":"removeOne","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":"uint256","name":"serialId","type":"uint256"},{"internalType":"uint256","name":"baseId","type":"uint256"}],"name":"setSerialNextId","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"serialId","type":"uint256"},{"internalType":"uint256","name":"_totalSupply","type":"uint256"}],"name":"setTotalSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000114d6574615620446973636f76657265723100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000054d45544156000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002068747470733a2f2f6d657461762e6c6976652f6d642f70726f766973696f6e2f

-----Decoded View---------------
Arg [0] : name (string): MetaV Discoverer1
Arg [1] : symbol (string): METAV
Arg [2] : _defaultTokenURI (string): https://metav.live/md/provision/

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000011
Arg [4] : 4d6574615620446973636f766572657231000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [6] : 4d45544156000000000000000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [8] : 68747470733a2f2f6d657461762e6c6976652f6d642f70726f766973696f6e2f

67040:1790:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9057:192;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50644:98;;;:::i;:::-;;;;;;;:::i;53999:294::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;53516:422::-;;;;;;:::i;:::-;;:::i;:::-;;52966:208;;;:::i;:::-;;;;;;;:::i;55011:363::-;;;;;;:::i;:::-;;:::i;52691:204::-;;;;;;:::i;:::-;;:::i;55440:179::-;;;;;;:::i;:::-;;:::i;53246:213::-;;;;;;:::i;:::-;;:::i;50306:276::-;;;;;;:::i;:::-;;:::i;52517:95::-;;;:::i;49954:295::-;;;;;;:::i;:::-;;:::i;1598:92:2:-;;;:::i;67469:226:1:-;;;;;;:::i;:::-;;:::i;966:85:2:-;;;:::i;68124:111:1:-;;;;;;:::i;:::-;;:::i;68241:312::-;;;;;;:::i;:::-;;:::i;50806:102::-;;;:::i;358:90:3:-;;;;;;:::i;:::-;;:::i;54360:317:1:-;;;;;;:::i;:::-;;:::i;67964:154::-;;;;;;:::i;:::-;;:::i;55685:353::-;;;;;;:::i;:::-;;:::i;67848:110::-;;;;;;:::i;:::-;;:::i;50974:810::-;;;;;;:::i;:::-;;:::i;454:157:3:-;;;;;;:::i;:::-;;:::i;68559:269:1:-;;;;;;:::i;:::-;;:::i;54743:206::-;;;;;;:::i;:::-;;:::i;1839:189:2:-;;;;;;:::i;:::-;;:::i;67701:141:1:-;;;;;;:::i;:::-;;:::i;9057:192::-;-1:-1:-1;;;;;;9209:33:1;;9182:4;9209:33;;;;;;;;;;;;;9057:192;;;;:::o;50644:98::-;50698:13;50730:5;50723:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50644:98;:::o;53999:294::-;54115:7;54159:16;54167:7;54159;:16::i;:::-;54138:106;;;;-1:-1:-1;;;54138:106:1;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;54262:24:1;;;;:15;:24;;;;;;-1:-1:-1;;;;;54262:24:1;;53999:294::o;53516:422::-;53596:13;53612:23;53627:7;53612:14;:23::i;:::-;53596:39;;53659:5;-1:-1:-1;;;;;53653:11:1;:2;-1:-1:-1;;;;;53653:11:1;;;53645:56;;;;-1:-1:-1;;;53645:56:1;;;;;;;:::i;:::-;53749:5;-1:-1:-1;;;;;53733:21:1;:12;:10;:12::i;:::-;-1:-1:-1;;;;;53733:21:1;;:85;;;;53774:44;53798:5;53805:12;:10;:12::i;53774:44::-;53712:187;;;;-1:-1:-1;;;53712:187:1;;;;;;;:::i;:::-;53910:21;53919:2;53923:7;53910:8;:21::i;:::-;53516:422;;;:::o;52966:208::-;53027:7;53146:21;:12;:19;:21::i;:::-;53139:28;;52966:208;:::o;55011:363::-;55213:41;55232:12;:10;:12::i;:::-;55246:7;55213:18;:41::i;:::-;55192:136;;;;-1:-1:-1;;;55192:136:1;;;;;;;:::i;:::-;55339:28;55349:4;55355:2;55359:7;55339:9;:28::i;52691:204::-;-1:-1:-1;;;;;52858:20:1;;52828:7;52858:20;;;:13;:20;;;;;:30;;52882:5;52858:23;:30::i;:::-;52851:37;;52691:204;;;;;:::o;55440:179::-;55573:39;55590:4;55596:2;55600:7;55573:39;;;;;;;;;;;;:16;:39::i;53246:213::-;53361:7;;53406:22;:12;53422:5;53406:15;:22::i;:::-;-1:-1:-1;53384:44:1;53246:213;-1:-1:-1;;;53246:213:1:o;50306:276::-;50418:7;50460:115;50494:7;50460:115;;;;;;;;;;;;;;;;;:12;;:115;:16;:115::i;52517:95::-;52565:13;52597:8;52590:15;;;;;:::i;49954:295::-;50066:7;-1:-1:-1;;;;;50110:19:1;;50089:107;;;;-1:-1:-1;;;50089:107:1;;;;;;;:::i;:::-;-1:-1:-1;;;;;50213:20:1;;;;;;:13;:20;;;;;:29;;:27;:29::i;1598:92:2:-;1189:12;:10;:12::i;:::-;-1:-1:-1;;;;;1178:23:2;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1178:23:2;;1170:68;;;;-1:-1:-1;;;1170:68:2;;;;;;;:::i;:::-;1662:21:::1;1680:1;1662:9;:21::i;:::-;1598:92::o:0;67469:226:1:-;289:10:3;303:1;278:22;;;:10;:22;;;;;;270:64;;;;-1:-1:-1;;;270:64:3;;;;;;;:::i;:::-;67600:33:1::1;67616:8;67626:6;67600:15;:33::i;:::-;67643:45;67658:8:::0;67668:19:::1;67677:10:::0;67668:6;:19:::1;:::i;966:85:2:-:0;1038:6;;-1:-1:-1;;;;;1038:6:2;966:85;:::o;68124:111:1:-;68182:7;68208:20;;;:10;:20;;;;;;;68124:111::o;68241:312::-;289:10:3;303:1;278:22;;;:10;:22;;;;;;270:64;;;;-1:-1:-1;;;270:64:3;;;;;;;:::i;:::-;68344:1:1::1;68323:18:::0;;;:8:::1;:18;::::0;;;;;68315:59:::1;;;;-1:-1:-1::0;;;68315:59:1::1;;;;;;;:::i;:::-;68427:20;::::0;;;:10:::1;:20;::::0;;;;;;;;68405:8:::1;:18:::0;;;;;;;:42:::1;;68384:119;;;;-1:-1:-1::0;;;68384:119:1::1;;;;;;;:::i;:::-;68525:18;::::0;;;:8:::1;:18;::::0;;;;:20;;68513:33:::1;::::0;68519:4;;68525:18;:20:::1;::::0;::::1;:::i;:::-;;;;;68513:5;:33::i;:::-;68241:312:::0;;:::o;50806:102::-;50862:13;50894:7;50887:14;;;;;:::i;358:90:3:-;1189:12:2;:10;:12::i;:::-;-1:-1:-1;;;;;1178:23:2;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1178:23:2;;1170:68;;;;-1:-1:-1;;;1170:68:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;418:19:3::1;;::::0;;;:10:::1;:19;::::0;;;;440:1:::1;418:23:::0;;358:90::o;54360:317:1:-;54502:12;:10;:12::i;:::-;-1:-1:-1;;;;;54490:24:1;:8;-1:-1:-1;;;;;54490:24:1;;;54482:61;;;;-1:-1:-1;;;54482:61:1;;;;;;;:::i;:::-;54599:8;54554:18;:32;54573:12;:10;:12::i;:::-;-1:-1:-1;;;;;54554:32:1;;;;;;;;;;;;;;;;;-1:-1:-1;54554:32:1;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;54554:53:1;;;;;;;;;;;54637:12;:10;:12::i;:::-;-1:-1:-1;;;;;54622:48:1;;54661:8;54622:48;;;;;;:::i;:::-;;;;;;;;54360:317;;:::o;67964:154::-;289:10:3;303:1;278:22;;;:10;:22;;;;;;270:64;;;;-1:-1:-1;;;270:64:3;;;;;;;:::i;:::-;68076:20:1::1;::::0;;;:10:::1;:20;::::0;;;;;:35;67964:154::o;55685:353::-;55867:41;55886:12;:10;:12::i;:::-;55900:7;55867:18;:41::i;:::-;55846:136;;;;-1:-1:-1;;;55846:136:1;;;;;;;:::i;:::-;55992:39;56006:4;56012:2;56016:7;56025:5;55992:13;:39::i;:::-;55685:353;;;;:::o;67848:110::-;67907:7;67933:18;;;:8;:18;;;;;;;67848:110::o;50974:810::-;51087:13;51124:16;51132:7;51124;:16::i;:::-;51116:67;;;;-1:-1:-1;;;51116:67:1;;;;;;;:::i;:::-;51194:23;51220:19;;;:10;:19;;;;;51194:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51249:18;51270:9;:7;:9::i;:::-;51249:30;;51358:4;51352:18;51374:1;51352:23;51348:70;;;-1:-1:-1;51398:9:1;-1:-1:-1;51391:16:1;;51348:70;51520:23;;:27;51516:106;;51594:4;51600:9;51577:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;51563:48;;;;;;51516:106;51752:4;51758:17;51767:7;51758:8;:17::i;:::-;51735:41;;;;;;;;;:::i;:::-;;;;;;;;;;;;;51721:56;;;;50974:810;;;:::o;454:157:3:-;1189:12:2;:10;:12::i;:::-;-1:-1:-1;;;;;1178:23:2;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1178:23:2;;1170:68;;;;-1:-1:-1;;;1170:68:2;;;;;;;:::i;:::-;536:7:3::1;:5;:7::i;:::-;-1:-1:-1::0;;;;;525:18:3::1;:7;-1:-1:-1::0;;;;;525:18:3::1;;;517:51;;;;-1:-1:-1::0;;;517:51:3::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;585:19:3::1;;::::0;;;:10:::1;:19;::::0;;;;578:26;454:157::o;68559:269:1:-;289:10:3;303:1;278:22;;;:10;:22;;;;;;270:64;;;;-1:-1:-1;;;270:64:3;;;;;;;:::i;:::-;68700:2:1::1;68691:5;:11;;68683:48;;;;-1:-1:-1::0;;;68683:48:1::1;;;;;;;:::i;:::-;68746:9;68741:81;68765:5;68761:1;:9;68741:81;;;68791:20;68796:8;68806:4;68791;:20::i;:::-;68772:3:::0;::::1;::::0;::::1;:::i;:::-;;;;68741:81;;54743:206:::0;-1:-1:-1;;;;;54907:25:1;;;54880:4;54907:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;54743:206::o;1839:189:2:-;1189:12;:10;:12::i;:::-;-1:-1:-1;;;;;1178:23:2;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1178:23:2;;1170:68;;;;-1:-1:-1;;;1170:68:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;1927:22:2;::::1;1919:73;;;;-1:-1:-1::0;;;1919:73:2::1;;;;;;;:::i;:::-;2002:19;2012:8;2002:9;:19::i;:::-;1839:189:::0;:::o;67701:141:1:-;289:10:3;303:1;278:22;;;:10;:22;;;;;;270:64;;;;-1:-1:-1;;;270:64:3;;;;;;;:::i;:::-;67808:18:1::1;::::0;;;:8:::1;:18;::::0;;;;;:27;67701:141::o;57543:125::-;57608:4;57631:30;:12;57653:7;57631:21;:30::i;587:96:0:-;666:10;587:96;:::o;63592:180:1:-;63657:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;63657:29:1;-1:-1:-1;;;;;63657:29:1;;;;;;;;:24;;63710:23;63657:24;63710:14;:23::i;:::-;-1:-1:-1;;;;;63701:46:1;;;;;;;;;;;63592:180;;:::o;43396:149::-;43489:7;43519:19;43527:3;43519:7;:19::i;57826:444::-;57951:4;57992:16;58000:7;57992;:16::i;:::-;57971:106;;;;-1:-1:-1;;;57971:106:1;;;;;;;:::i;:::-;58087:13;58103:23;58118:7;58103:14;:23::i;:::-;58087:39;;58155:5;-1:-1:-1;;;;;58144:16:1;:7;-1:-1:-1;;;;;58144:16:1;;:63;;;;58200:7;-1:-1:-1;;;;;58176:31:1;:20;58188:7;58176:11;:20::i;:::-;-1:-1:-1;;;;;58176:31:1;;58144:63;:118;;;;58223:39;58247:5;58254:7;58223:23;:39::i;:::-;58136:127;57826:444;-1:-1:-1;;;;57826:444:1:o;61021:646::-;61188:4;-1:-1:-1;;;;;61161:31:1;:23;61176:7;61161:14;:23::i;:::-;-1:-1:-1;;;;;61161:31:1;;61140:118;;;;-1:-1:-1;;;61140:118:1;;;;;;;:::i;:::-;-1:-1:-1;;;;;61294:16:1;;61286:64;;;;-1:-1:-1;;;61286:64:1;;;;;;;:::i;:::-;61361:39;61382:4;61388:2;61392:7;61361:20;:39::i;:::-;61462:29;61479:1;61483:7;61462:8;:29::i;:::-;-1:-1:-1;;;;;61502:19:1;;;;;;:13;:19;;;;;:35;;61529:7;61502:26;:35::i;:::-;-1:-1:-1;;;;;;61547:17:1;;;;;;:13;:17;;;;;:30;;61569:7;61547:21;:30::i;:::-;-1:-1:-1;61588:29:1;:12;61605:7;61614:2;61588:16;:29::i;:::-;;61652:7;61648:2;-1:-1:-1;;;;;61633:27:1;61642:4;-1:-1:-1;;;;;61633:27:1;;;;;;;;;;;61021:646;;;:::o;35189:163::-;35284:7;35322:22;35326:3;35338:5;35322:3;:22::i;43882:261::-;43986:7;;;;44049:22;44053:3;44065:5;44049:3;:22::i;:::-;44018:53;;;;-1:-1:-1;43882:261:1;-1:-1:-1;;;;;43882:261:1:o;45219:283::-;45356:7;45435:44;45440:3;45460;45466:12;45435:4;:44::i;:::-;45427:53;-1:-1:-1;45219:283:1;;;;;;:::o;2034:169:2:-;2108:6;;;-1:-1:-1;;;;;2124:17:2;;;-1:-1:-1;;;;;;2124:17:2;;;;;;;2156:40;;2108:6;;;2124:17;2108:6;;2156:40;;2089:16;;2156:40;2034:169;;:::o;59562:391:1:-;-1:-1:-1;;;;;59641:16:1;;59633:60;;;;-1:-1:-1;;;59633:60:1;;;;;;;:::i;:::-;59712:16;59720:7;59712;:16::i;:::-;59711:17;59703:57;;;;-1:-1:-1;;;59703:57:1;;;;;;;:::i;:::-;59771:45;59800:1;59804:2;59808:7;59771:20;:45::i;:::-;-1:-1:-1;;;;;59827:17:1;;;;;;:13;:17;;;;;:30;;59849:7;59827:21;:30::i;:::-;-1:-1:-1;59868:29:1;:12;59885:7;59894:2;59868:16;:29::i;:::-;-1:-1:-1;59913:33:1;;59938:7;;-1:-1:-1;;;;;59913:33:1;;;59930:1;;59913:33;;59930:1;;59913:33;59562:391;;:::o;56900:340::-;57051:28;57061:4;57067:2;57071:7;57051:9;:28::i;:::-;57110:48;57133:4;57139:2;57143:7;57152:5;57110:22;:48::i;:::-;57089:144;;;;-1:-1:-1;;;57089:144:1;;;;;;;:::i;51790:491::-;51843:17;51876:7;51872:48;;-1:-1:-1;51899:10:1;;;;;;;;;;;;-1:-1:-1;;;51899:10:1;;;;;;51872:48;51941:2;51929:9;51977:69;51984:6;;51977:69;;52006:8;;;;:::i;:::-;;-1:-1:-1;52028:7:1;;-1:-1:-1;52033:2:1;52028:7;;:::i;:::-;;;51977:69;;;52055:17;52085:6;52075:17;;;;;;-1:-1:-1;;;52075:17:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52075:17:1;-1:-1:-1;52134:2:1;;-1:-1:-1;52055:37:1;-1:-1:-1;52114:6:1;52146:101;52153:6;;52146:101;;52206:6;52210:2;52206:1;:6;:::i;:::-;52200:13;;:2;:13;:::i;:::-;52187:28;;52175:4;52180:3;;;:::i;:::-;;;;52175:9;;;;;;-1:-1:-1;;;52175:9:1;;;;;;;;;;;;:40;-1:-1:-1;;;;;52175:40:1;;;;;;;;-1:-1:-1;52229:7:1;52234:2;52229:7;;:::i;:::-;;;52146:101;;;-1:-1:-1;52269:4:1;51790:491;-1:-1:-1;;;;51790:491:1:o;43136:177::-;43244:4;43271:35;43281:3;43301;43271:9;:35::i;39859:108::-;39941:19;;39859:108::o;34246:155::-;34332:4;34359:35;34367:3;34387:5;34359:7;:35::i;33949:129::-;34016:4;34039:32;34044:3;34064:5;34039:4;:32::i;42525:213::-;42644:4;42667:64;42672:3;42692;-1:-1:-1;;;;;42706:23:1;;42667:4;:64::i;30060:263::-;30195:18;;30151:7;;30195:26;-1:-1:-1;30174:107:1;;;;-1:-1:-1;;;30174:107:1;;;;;;;:::i;:::-;30298:3;:11;;30310:5;30298:18;;;;;;-1:-1:-1;;;30298:18:1;;;;;;;;;;;;;;;;;30291:25;;30060:263;;;;:::o;40320:336::-;40464:19;;40411:7;;;;40464:27;-1:-1:-1;40443:108:1;;;;-1:-1:-1;;;40443:108:1;;;;;;;:::i;:::-;40562:22;40587:3;:12;;40600:5;40587:19;;;;;;-1:-1:-1;;;40587:19:1;;;;;;;;;;;;;;;;;;;40562:44;;40624:5;:10;;;40636:5;:12;;;40616:33;;;;;40320:336;;;;;:::o;41871:345::-;41995:7;42033:17;;;:12;;;:17;;;;;;42083:12;42068:13;42060:36;;;;-1:-1:-1;;;42060:36:1;;;;;;;;:::i;:::-;-1:-1:-1;42149:3:1;42162:12;42173:1;42162:8;:12;:::i;:::-;42149:26;;;;;;-1:-1:-1;;;42149:26:1;;;;;;;;;;;;;;;;;;;:33;;;42142:40;;;41871:345;;;;;:::o;62914:672::-;63064:4;63085:15;:2;-1:-1:-1;;;;;63085:13:1;;:15::i;:::-;63080:58;;-1:-1:-1;63123:4:1;63116:11;;63080:58;63147:23;63173:303;-1:-1:-1;;;63305:12:1;:10;:12::i;:::-;63335:4;63357:7;63382:5;63202:199;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;63202:199:1;;;;;;;-1:-1:-1;;;;;63202:199:1;;;;;;;;;;;63173:303;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;63173:15:1;;;:303;:15;:303::i;:::-;63147:329;;63486:13;63513:10;63502:32;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;63552:26:1;-1:-1:-1;;;63552:26:1;;-1:-1:-1;;;62914:672:1;;;;;;:::o;39618:151::-;39713:4;39740:17;;;:12;;;;;:17;;;;;;:22;;;39618:151::o;27770:1524::-;27836:4;27973:19;;;:12;;;:19;;;;;;28007:15;;28003:1285;;28376:21;28400:14;28413:1;28400:10;:14;:::i;:::-;28448:18;;28376:38;;-1:-1:-1;28428:17:1;;28448:22;;28469:1;;28448:22;:::i;:::-;28428:42;;28710:17;28730:3;:11;;28742:9;28730:22;;;;;;-1:-1:-1;;;28730:22:1;;;;;;;;;;;;;;;;;28710:42;;28873:9;28844:3;:11;;28856:13;28844:26;;;;;;-1:-1:-1;;;28844:26:1;;;;;;;;;;;;;;;;;;:38;28974:17;:13;28990:1;28974:17;:::i;:::-;28948:23;;;;:12;;;:23;;;;;:43;29097:17;;28948:3;;29097:17;;;-1:-1:-1;;;29097:17:1;;;;;;;;;;;;;;;;;;;;;;;;;;29189:3;:12;;:19;29202:5;29189:19;;;;;;;;;;;29182:26;;;29230:4;29223:11;;;;;;;;28003:1285;29272:5;29265:12;;;;;27198:404;27261:4;27282:21;27292:3;27297:5;27282:9;:21::i;:::-;27277:319;;-1:-1:-1;27319:23:1;;;;;;;;:11;:23;;;;;;;;;;;;;27499:18;;27477:19;;;:12;;;:19;;;;;;:40;;;;27531:11;;27277:319;-1:-1:-1;27580:5:1;27573:12;;37124:718;37230:4;37363:17;;;:12;;;:17;;;;;;37395:13;37391:445;;-1:-1:-1;;37491:36:1;;;;;;;;;;;;;;;;;;37473:55;;;;;;;;:12;:55;;;;;;;;;;;;;;;;;;;;;;;;37683:19;;37663:17;;;:12;;;:17;;;;;;;:39;37716:11;;37391:445;37794:5;37758:3;37771:12;37782:1;37771:8;:12;:::i;:::-;37758:26;;;;;;-1:-1:-1;;;37758:26:1;;;;;;;;;;;;;;;;;;;:33;;:41;;;;37820:5;37813:12;;;;;17895:433;18267:20;18313:8;;;17895:433::o;20858:223::-;20991:12;21022:52;21044:6;21052:4;21058:1;21061:12;20991;22357:18;22368:6;22357:10;:18::i;:::-;22349:60;;;;-1:-1:-1;;;22349:60:1;;;;;;;:::i;:::-;22480:12;22494:23;22521:6;-1:-1:-1;;;;;22521:11:1;22540:5;22560:4;22521:53;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22479:95;;;;22591:52;22609:7;22618:10;22630:12;22591:17;:52::i;:::-;22584:59;22035:615;-1:-1:-1;;;;;;;22035:615:1:o;24866:756::-;25012:12;25040:7;25036:580;;;-1:-1:-1;25070:10:1;25063:17;;25036:580;25181:17;;:21;25177:429;;25439:10;25433:17;25499:15;25486:10;25482:2;25478:19;25471:44;25388:145;25578:12;25571:20;;-1:-1:-1;;;25571:20:1;;;;;;;;:::i;14:175:4:-;84:20;;-1:-1:-1;;;;;133:31:4;;123:42;;113:2;;179:1;176;169:12;194:198;;306:2;294:9;285:7;281:23;277:32;274:2;;;327:6;319;312:22;274:2;355:31;376:9;355:31;:::i;397:274::-;;;526:2;514:9;505:7;501:23;497:32;494:2;;;547:6;539;532:22;494:2;575:31;596:9;575:31;:::i;:::-;565:41;;625:40;661:2;650:9;646:18;625:40;:::i;:::-;615:50;;484:187;;;;;:::o;676:342::-;;;;822:2;810:9;801:7;797:23;793:32;790:2;;;843:6;835;828:22;790:2;871:31;892:9;871:31;:::i;:::-;861:41;;921:40;957:2;946:9;942:18;921:40;:::i;:::-;911:50;;1008:2;997:9;993:18;980:32;970:42;;780:238;;;;;:::o;1023:1178::-;;;;;1195:3;1183:9;1174:7;1170:23;1166:33;1163:2;;;1217:6;1209;1202:22;1163:2;1245:31;1266:9;1245:31;:::i;:::-;1235:41;;1295:2;1316:40;1352:2;1341:9;1337:18;1316:40;:::i;:::-;1306:50;;1403:2;1392:9;1388:18;1375:32;1365:42;;1458:2;1447:9;1443:18;1430:32;1481:18;1522:2;1514:6;1511:14;1508:2;;;1543:6;1535;1528:22;1508:2;1586:6;1575:9;1571:22;1561:32;;1631:7;1624:4;1620:2;1616:13;1612:27;1602:2;;1658:6;1650;1643:22;1602:2;1699;1686:16;1721:2;1717;1714:10;1711:2;;;1727:18;;:::i;:::-;1776:2;1770:9;1845:2;1826:13;;-1:-1:-1;;1822:27:4;1810:40;;1806:49;;1870:18;;;1890:22;;;1867:46;1864:2;;;1916:18;;:::i;:::-;1952:2;1945:22;1976:18;;;2013:11;;;2009:20;;2006:33;-1:-1:-1;2003:2:4;;;2057:6;2049;2042:22;2003:2;2118;2113;2109;2105:11;2100:2;2092:6;2088:15;2075:46;2141:15;;;2137:24;;;2130:40;;;;-1:-1:-1;1153:1048:4;;;;-1:-1:-1;1153:1048:4;;-1:-1:-1;;1153:1048:4:o;2206:369::-;;;2332:2;2320:9;2311:7;2307:23;2303:32;2300:2;;;2353:6;2345;2338:22;2300:2;2381:31;2402:9;2381:31;:::i;:::-;2371:41;;2462:2;2451:9;2447:18;2434:32;2509:5;2502:13;2495:21;2488:5;2485:32;2475:2;;2536:6;2528;2521:22;2475:2;2564:5;2554:15;;;2290:285;;;;;:::o;2580:266::-;;;2709:2;2697:9;2688:7;2684:23;2680:32;2677:2;;;2730:6;2722;2715:22;2677:2;2758:31;2779:9;2758:31;:::i;:::-;2748:41;2836:2;2821:18;;;;2808:32;;-1:-1:-1;;;2667:179:4:o;2851:257::-;;2962:2;2950:9;2941:7;2937:23;2933:32;2930:2;;;2983:6;2975;2968:22;2930:2;3027:9;3014:23;3046:32;3072:5;3046:32;:::i;3113:261::-;;3235:2;3223:9;3214:7;3210:23;3206:32;3203:2;;;3256:6;3248;3241:22;3203:2;3293:9;3287:16;3312:32;3338:5;3312:32;:::i;3379:190::-;;3491:2;3479:9;3470:7;3466:23;3462:32;3459:2;;;3512:6;3504;3497:22;3459:2;-1:-1:-1;3540:23:4;;3449:120;-1:-1:-1;3449:120:4:o;3574:266::-;;;3703:2;3691:9;3682:7;3678:23;3674:32;3671:2;;;3724:6;3716;3709:22;3671:2;3765:9;3752:23;3742:33;;3794:40;3830:2;3819:9;3815:18;3794:40;:::i;3845:334::-;;;;3991:2;3979:9;3970:7;3966:23;3962:32;3959:2;;;4012:6;4004;3997:22;3959:2;4053:9;4040:23;4030:33;;4082:40;4118:2;4107:9;4103:18;4082:40;:::i;4184:258::-;;;4313:2;4301:9;4292:7;4288:23;4284:32;4281:2;;;4334:6;4326;4319:22;4281:2;-1:-1:-1;;4362:23:4;;;4432:2;4417:18;;;4404:32;;-1:-1:-1;4271:171:4:o;4447:326::-;;;;4593:2;4581:9;4572:7;4568:23;4564:32;4561:2;;;4614:6;4606;4599:22;4561:2;-1:-1:-1;;4642:23:4;;;4712:2;4697:18;;4684:32;;-1:-1:-1;4763:2:4;4748:18;;;4735:32;;4551:222;-1:-1:-1;4551:222:4:o;4778:259::-;;4859:5;4853:12;4886:6;4881:3;4874:19;4902:63;4958:6;4951:4;4946:3;4942:14;4935:4;4928:5;4924:16;4902:63;:::i;:::-;5019:2;4998:15;-1:-1:-1;;4994:29:4;4985:39;;;;5026:4;4981:50;;4829:208;-1:-1:-1;;4829:208:4:o;5042:274::-;;5209:6;5203:13;5225:53;5271:6;5266:3;5259:4;5251:6;5247:17;5225:53;:::i;:::-;5294:16;;;;;5179:137;-1:-1:-1;;5179:137:4:o;5321:470::-;;5538:6;5532:13;5554:53;5600:6;5595:3;5588:4;5580:6;5576:17;5554:53;:::i;:::-;5670:13;;5629:16;;;;5692:57;5670:13;5629:16;5726:4;5714:17;;5692:57;:::i;:::-;5765:20;;5508:283;-1:-1:-1;;;;5508:283:4:o;5796:203::-;-1:-1:-1;;;;;5960:32:4;;;;5942:51;;5930:2;5915:18;;5897:102::o;6004:490::-;-1:-1:-1;;;;;6273:15:4;;;6255:34;;6325:15;;6320:2;6305:18;;6298:43;6372:2;6357:18;;6350:34;;;6420:3;6415:2;6400:18;;6393:31;;;6004:490;;6441:47;;6468:19;;6460:6;6441:47;:::i;:::-;6433:55;6207:287;-1:-1:-1;;;;;;6207:287:4:o;6499:187::-;6664:14;;6657:22;6639:41;;6627:2;6612:18;;6594:92::o;6691:221::-;;6840:2;6829:9;6822:21;6860:46;6902:2;6891:9;6887:18;6879:6;6860:46;:::i;6917:398::-;7119:2;7101:21;;;7158:2;7138:18;;;7131:30;7197:34;7192:2;7177:18;;7170:62;-1:-1:-1;;;7263:2:4;7248:18;;7241:32;7305:3;7290:19;;7091:224::o;7320:399::-;7522:2;7504:21;;;7561:2;7541:18;;;7534:30;7600:34;7595:2;7580:18;;7573:62;-1:-1:-1;;;7666:2:4;7651:18;;7644:33;7709:3;7694:19;;7494:225::o;7724:405::-;7926:2;7908:21;;;7965:2;7945:18;;;7938:30;8004:34;7999:2;7984:18;;7977:62;-1:-1:-1;;;8070:2:4;8055:18;;8048:39;8119:3;8104:19;;7898:231::o;8134:344::-;8336:2;8318:21;;;8375:2;8355:18;;;8348:30;-1:-1:-1;;;8409:2:4;8394:18;;8387:50;8469:2;8454:18;;8308:170::o;8483:402::-;8685:2;8667:21;;;8724:2;8704:18;;;8697:30;8763:34;8758:2;8743:18;;8736:62;-1:-1:-1;;;8829:2:4;8814:18;;8807:36;8875:3;8860:19;;8657:228::o;8890:407::-;9092:2;9074:21;;;9131:2;9111:18;;;9104:30;9170:34;9165:2;9150:18;;9143:62;-1:-1:-1;;;9236:2:4;9221:18;;9214:41;9287:3;9272:19;;9064:233::o;9302:412::-;9504:2;9486:21;;;9543:2;9523:18;;;9516:30;9582:34;9577:2;9562:18;;9555:62;-1:-1:-1;;;9648:2:4;9633:18;;9626:46;9704:3;9689:19;;9476:238::o;9719:351::-;9921:2;9903:21;;;9960:2;9940:18;;;9933:30;9999:29;9994:2;9979:18;;9972:57;10061:2;10046:18;;9893:177::o;10075:348::-;10277:2;10259:21;;;10316:2;10296:18;;;10289:30;10355:26;10350:2;10335:18;;10328:54;10414:2;10399:18;;10249:174::o;10835:348::-;11037:2;11019:21;;;11076:2;11056:18;;;11049:30;11115:26;11110:2;11095:18;;11088:54;11174:2;11159:18;;11009:174::o;11188:404::-;11390:2;11372:21;;;11429:2;11409:18;;;11402:30;11468:34;11463:2;11448:18;;11441:62;-1:-1:-1;;;11534:2:4;11519:18;;11512:38;11582:3;11567:19;;11362:230::o;11597:407::-;11799:2;11781:21;;;11838:2;11818:18;;;11811:30;11877:34;11872:2;11857:18;;11850:62;-1:-1:-1;;;11943:2:4;11928:18;;11921:41;11994:3;11979:19;;11771:233::o;12009:349::-;12211:2;12193:21;;;12250:2;12230:18;;;12223:30;12289:27;12284:2;12269:18;;12262:55;12349:2;12334:18;;12183:175::o;12363:402::-;12565:2;12547:21;;;12604:2;12584:18;;;12577:30;12643:34;12638:2;12623:18;;12616:62;-1:-1:-1;;;12709:2:4;12694:18;;12687:36;12755:3;12740:19;;12537:228::o;12770:398::-;12972:2;12954:21;;;13011:2;12991:18;;;12984:30;13050:34;13045:2;13030:18;;13023:62;-1:-1:-1;;;13116:2:4;13101:18;;13094:32;13158:3;13143:19;;12944:224::o;13173:348::-;13375:2;13357:21;;;13414:2;13394:18;;;13387:30;13453:26;13448:2;13433:18;;13426:54;13512:2;13497:18;;13347:174::o;13526:356::-;13728:2;13710:21;;;13747:18;;;13740:30;13806:34;13801:2;13786:18;;13779:62;13873:2;13858:18;;13700:182::o;13887:355::-;14089:2;14071:21;;;14128:2;14108:18;;;14101:30;14167:33;14162:2;14147:18;;14140:61;14233:2;14218:18;;14061:181::o;14247:354::-;14449:2;14431:21;;;14488:2;14468:18;;;14461:30;14527:32;14522:2;14507:18;;14500:60;14592:2;14577:18;;14421:180::o;14606:356::-;14808:2;14790:21;;;14827:18;;;14820:30;14886:34;14881:2;14866:18;;14859:62;14953:2;14938:18;;14780:182::o;14967:413::-;15169:2;15151:21;;;15208:2;15188:18;;;15181:30;15247:34;15242:2;15227:18;;15220:62;-1:-1:-1;;;15313:2:4;15298:18;;15291:47;15370:3;15355:19;;15141:239::o;15385:353::-;15587:2;15569:21;;;15626:2;15606:18;;;15599:30;15665:31;15660:2;15645:18;;15638:59;15729:2;15714:18;;15559:179::o;15743:419::-;15945:2;15927:21;;;15984:2;15964:18;;;15957:30;16023:34;16018:2;16003:18;;15996:62;16094:25;16089:2;16074:18;;16067:53;16152:3;16137:19;;15917:245::o;16167:177::-;16313:25;;;16301:2;16286:18;;16268:76::o;16349:128::-;;16420:1;16416:6;16413:1;16410:13;16407:2;;;16426:18;;:::i;:::-;-1:-1:-1;16462:9:4;;16397:80::o;16482:120::-;;16548:1;16538:2;;16553:18;;:::i;:::-;-1:-1:-1;16587:9:4;;16528:74::o;16607:125::-;;16675:1;16672;16669:8;16666:2;;;16680:18;;:::i;:::-;-1:-1:-1;16717:9:4;;16656:76::o;16737:258::-;16809:1;16819:113;16833:6;16830:1;16827:13;16819:113;;;16909:11;;;16903:18;16890:11;;;16883:39;16855:2;16848:10;16819:113;;;16950:6;16947:1;16944:13;16941:2;;;-1:-1:-1;;16985:1:4;16967:16;;16960:27;16790:205::o;17000:136::-;;17067:5;17057:2;;17076:18;;:::i;:::-;-1:-1:-1;;;17112:18:4;;17047:89::o;17141:380::-;17226:1;17216:12;;17273:1;17263:12;;;17284:2;;17338:4;17330:6;17326:17;17316:27;;17284:2;17391;17383:6;17380:14;17360:18;17357:38;17354:2;;;17437:10;17432:3;17428:20;17425:1;17418:31;17472:4;17469:1;17462:15;17500:4;17497:1;17490:15;17354:2;;17196:325;;;:::o;17526:135::-;;-1:-1:-1;;17586:17:4;;17583:2;;;17606:18;;:::i;:::-;-1:-1:-1;17653:1:4;17642:13;;17573:88::o;17666:112::-;;17724:1;17714:2;;17729:18;;:::i;:::-;-1:-1:-1;17763:9:4;;17704:74::o;17783:127::-;17844:10;17839:3;17835:20;17832:1;17825:31;17875:4;17872:1;17865:15;17899:4;17896:1;17889:15;17915:127;17976:10;17971:3;17967:20;17964:1;17957:31;18007:4;18004:1;17997:15;18031:4;18028:1;18021:15;18047:127;18108:10;18103:3;18099:20;18096:1;18089:31;18139:4;18136:1;18129:15;18163:4;18160:1;18153:15;18179:133;-1:-1:-1;;;;;;18255:32:4;;18245:43;;18235:2;;18302:1;18299;18292:12

ipfs://f0379f96987c8b5f4eb9b0c9a647602f4594d2469c4783a306825e18dffe4bac