Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
•    - function _msgSender()
•    - function _msgData()
• library Strings
•    - function toString(uint256 value)
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(address ...
•    - function _verifyCallResult(bool succe ...
• interface IERC165
•    - function supportsInterface(bytes4 int ...
•  contract ERC165 is IERC165
•    - function supportsInterface(bytes4 int ...
•    - function _registerInterface(bytes4 in ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
•    - function burn(uint256 burnQuantity)
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(address fro ...
•    - function transferFrom(address from, a ...
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(address fro ...
• interface IERC721Enumerable is IERC72 ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
• library EnumerableMap
•    - function _set(Map storage map, bytes3 ...
•    - function _remove(Map storage map, byt ...
•    - function _contains(Map storage map, b ...
•    - function _length(Map storage map)
•    - function _at(Map storage map, uint256 ...
•    - function _get(Map storage map, bytes3 ...
•    - function _get(Map storage map, bytes3 ...
•    - function set(UintToAddressMap storage ...
•    - function remove(UintToAddressMap stor ...
•    - function contains(UintToAddressMap st ...
•    - function length(UintToAddressMap stor ...
•    - function at(UintToAddressMap storage ...
•    - function get(UintToAddressMap storage ...
•    - function get(UintToAddressMap storage ...
• library EnumerableSet
•    - function _add(Set storage set, bytes3 ...
•    - function _remove(Set storage set, byt ...
•    - function _contains(Set storage set, b ...
•    - function _length(Set storage set)
•    - function _at(Set storage set, uint256 ...
•    - function add(AddressSet storage set, ...
•    - function remove(AddressSet storage se ...
•    - function contains(AddressSet storage ...
•    - function length(AddressSet storage se ...
•    - function at(AddressSet storage set, u ...
•    - function add(UintSet storage set, uin ...
•    - function remove(UintSet storage set, ...
•    - function contains(UintSet storage set ...
•    - function length(UintSet storage set)
•    - function at(UintSet storage set, uint ...
•  contract Ownable is Context
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
• interface IWaifus is IERC721Enumerabl ...
•    - function isMintedBeforeReveal(uint256 ...
• interface IERC721Metadata is IERC721
•    - function name()
•    - function symbol()
• interface IERC721Receiver
•    - function onERC721Received(address ope ...
•  contract Waifus is Context, Ownabl ... *
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function name()
•    - function symbol()
•    - function tokenOfOwnerByIndex(address ...
•    - function totalSupply()
•    - function tokenByIndex(uint256 index)
•    - function tokenNameByIndex(uint256 ind ...
•    - function isNameReserved(string memory ...
•    - function isMintedBeforeReveal(uint256 ...
•    - function getNFTPrice()
•    - function mintNFT(uint256 numberOfNfts ...
•    - function finalizeStartingIndex()
•    - function changeName(uint256 tokenId, ...
•    - function withdraw()
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function transferFrom(address from, a ...
•    - function safeTransferFrom(address fro ...
•    - function safeTransferFrom(address fro ...
•    - function _safeTransfer(address from, ...
•    - function _exists(uint256 tokenId)
•    - function _isApprovedOrOwner(address s ...
•    - function _safeMint(address to, uint25 ...
•    - function _safeMint(address to, uint25 ...
•    - function _mint(address to, uint256 to ...
•    - function _burn(uint256 tokenId)
•    - function _transfer(address from, addr ...
•    - function _checkOnERC721Received(addre ...
•    - function _approve(address to, uint256 ...
•    - function _beforeTokenTransfer(address ...
•    - function toggleReserveName(string mem ...
•    - function validateName(string memory s ...
•    - function toLower(string memory str)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-03-01
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

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

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

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

        return c;
    }

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

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

        return c;
    }

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

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

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

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

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

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


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

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

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

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

    /**
     * @dev See {IERC165-supportsInterface}.
     *
     * Time complexity O(1), guaranteed to always use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) public view 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 Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);


    /**
     * TODO: Add comment
     */
    function burn(uint256 burnQuantity) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

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

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

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

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

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

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

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

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

            MapEntry storage lastEntry = map._entries[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        return _get(map, key, "EnumerableMap: nonexistent key");
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     */
    function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

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

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

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

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

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

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

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

/**
 * @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.0.0, only sets of type `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];
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

contract Ownable is Context {
    address private _owner;

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

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

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

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

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

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

interface IWaifus is IERC721Enumerable {
    function isMintedBeforeReveal(uint256 index) external view returns (bool);
}

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

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

/**
 * @title Waifus contract
 * @dev Extends ERC721 Non-Fungible Token Standard basic implementation
 */
contract Waifus is Context, Ownable, ERC165, IWaifus, IERC721Metadata {
    using SafeMath for uint256;
    using Address for address;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableMap for EnumerableMap.UintToAddressMap;
    using Strings for uint256;

    // Public variables

    // This is the provenance record of all Waifus artwork in existence
    string public constant WAIFUS_PROVENANCE = "b9e2ad47185076f3f43847eeec601e7bc4a1cb51a208b34b5eb1c650cf06a546";

    uint256 public constant SALE_START_TIMESTAMP = 1614624600;

    // Time after which waifus are randomized and allotted
    uint256 public constant REVEAL_TIMESTAMP = SALE_START_TIMESTAMP + (86400 * 14); 

    uint256 public constant NAME_CHANGE_PRICE = 1830 * (10 ** 18);

    uint256 public constant MAX_NFT_SUPPLY = 16384;

    uint256 public startingIndexBlock;

    uint256 public startingIndex;

    // 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 token ID to name
    mapping (uint256 => string) private _tokenName;

    // Mapping if certain name string has already been reserved
    mapping (string => bool) private _nameReserved;

    // Mapping from token ID to whether the Waifus was minted before reveal
    mapping (uint256 => bool) private _mintedBeforeReveal;
    
    // Mapping from owner to operator approvals
    mapping (address => mapping (address => bool)) private _operatorApprovals;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Waifu Enhancement Token address
    address private _wetAddress;
    
    

    /*
     *     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
     *
     *     => 0x06fdde03 ^ 0x95d89b41 == 0x93254542
     */
    bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x93254542;

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

    // Events
    event NameChange (uint256 indexed maskIndex, string newName);

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor (string memory name, string memory symbol, address wetAddress) {
        _name = name;
        _symbol = symbol;
        _wetAddress = wetAddress;

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");

        return _holderTokens[owner].length();
    }

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

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

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

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

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

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

    /**
     * @dev Returns name of the NFT at index.
     */
    function tokenNameByIndex(uint256 index) public view returns (string memory) {
        return _tokenName[index];
    }

    /**
     * @dev Returns if the name has been reserved.
     */
    function isNameReserved(string memory nameString) public view returns (bool) {
        return _nameReserved[toLower(nameString)];
    }

    /**
     * @dev Returns if the NFT has been minted before reveal phase
     */
    function isMintedBeforeReveal(uint256 index) public view override returns (bool) {
        return _mintedBeforeReveal[index];
    }

    /**
     * @dev Gets current Waifus Price
     */
    function getNFTPrice() public view returns (uint256) {
        require(block.timestamp >= SALE_START_TIMESTAMP, "Sale has not started");
        require(totalSupply() < MAX_NFT_SUPPLY, "Sale has already ended");

        uint currentSupply = totalSupply();

        if (currentSupply >= 16381) {
            return 100000000000000000000; // 16381 - 16383 100 ETH
        } else if (currentSupply >= 16000) {
            return 2000000000000000000; // 16000 - 16380 2.0 ETH
        } else if (currentSupply >= 15000) {
            return 1300000000000000000; // 15000  - 15999 1.3 ETH
        } else if (currentSupply >= 13000) {
            return 1100000000000000000; // 13000 - 14999 1.1 ETH
        } else if (currentSupply >= 11000) {
            return 900000000000000000; // 11000 - 12999 0.9 ETH
        } else if (currentSupply >= 9000) {
            return 700000000000000000; // 9000 - 10999 0.7 ETH
        } else if (currentSupply >= 7000) {
            return 500000000000000000; // 7000 - 8999 0.5 ETH
        } else if (currentSupply >= 5000) {
            return 400000000000000000; // 5000 - 6999 0.4 ETH
        } else if (currentSupply >= 3000) {
            return 300000000000000000; // 3000 - 4999 0.3 ETH
        } else if (currentSupply >= 1500) {
            return 200000000000000000; // 1500 - 2999 0.2 ETH
        } else {
            return 100000000000000000; // 0 - 1499 0.1 ETH 
        }
    }

    /**
    * @dev Mints Waifus
    */
    function mintNFT(uint256 numberOfNfts) public payable {
        require(totalSupply() < MAX_NFT_SUPPLY, "Sale has already ended");
        require(numberOfNfts > 0, "numberOfNfts cannot be 0");
        require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once");
        require(totalSupply().add(numberOfNfts) <= MAX_NFT_SUPPLY, "Exceeds MAX_NFT_SUPPLY");
        require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct");

        for (uint i = 0; i < numberOfNfts; i++) {
            uint mintIndex = totalSupply();
            if (block.timestamp < REVEAL_TIMESTAMP) {
                _mintedBeforeReveal[mintIndex] = true;
            }
            _safeMint(msg.sender, mintIndex);
        }

        /**
        * Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense
        */
        if (startingIndexBlock == 0 && (totalSupply() == MAX_NFT_SUPPLY || block.timestamp >= REVEAL_TIMESTAMP)) {
            startingIndexBlock = block.number;
        }
    }

    /**
     * @dev Finalize starting index
     */
    function finalizeStartingIndex() public {
        require(startingIndex == 0, "Starting index is already set");
        require(startingIndexBlock != 0, "Starting index block must be set");
        
        startingIndex = uint(blockhash(startingIndexBlock)) % MAX_NFT_SUPPLY;
        // Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
        if (block.number.sub(startingIndexBlock) > 255) {
            startingIndex = uint(blockhash(block.number-1)) % MAX_NFT_SUPPLY;
        }
        // Prevent default sequence
        if (startingIndex == 0) {
            startingIndex = startingIndex.add(1);
        }
    }

    /**
     * @dev Changes the name for Waifus tokenId
     */
    function changeName(uint256 tokenId, string memory newName) public {
        address owner = ownerOf(tokenId);

        require(_msgSender() == owner, "ERC721: caller is not the owner");
        require(validateName(newName) == true, "Not a valid new name");
        require(sha256(bytes(newName)) != sha256(bytes(_tokenName[tokenId])), "New name is same as the current one");
        require(isNameReserved(newName) == false, "Name already reserved");

        IERC20(_wetAddress).transferFrom(msg.sender, address(this), NAME_CHANGE_PRICE);
        // If already named, dereserve old name
        if (bytes(_tokenName[tokenId]).length > 0) {
            toggleReserveName(_tokenName[tokenId], false);
        }
        toggleReserveName(newName, true);
        _tokenName[tokenId] = newName;
        IERC20(_wetAddress).burn(NAME_CHANGE_PRICE);
        emit NameChange(tokenId, newName);
    }

    /**
     * @dev Withdraw ether from this contract (Callable by owner)
    */
    function withdraw() onlyOwner public {
        uint balance = address(this).balance;
        msg.sender.transfer(balance);
    }

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

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

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

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     d*
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        require(totalSupply() < 16385);
        _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(totalSupply() < 16385);
        require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

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

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

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

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

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

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

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(tokenId);

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        _tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }


    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
        private returns (bool)
    {
        if (!to.isContract()) {
            return true;
        }
        bytes memory returndata = to.functionCall(abi.encodeWithSelector(
            IERC721Receiver(to).onERC721Received.selector,
            _msgSender(),
            from,
            tokenId,
            _data
        ), "ERC721: transfer to non ERC721Receiver implementer");
        bytes4 retval = abi.decode(returndata, (bytes4));
        return (retval == _ERC721_RECEIVED);
    }

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

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

    /**
     * @dev Reserves the name if isReserve is set to true, de-reserves if set to false
     */
    function toggleReserveName(string memory str, bool isReserve) internal {
        _nameReserved[toLower(str)] = isReserve;
    }

    /**
     * @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space)
     */
    function validateName(string memory str) public pure returns (bool){
        bytes memory b = bytes(str);
        if(b.length < 1) return false;
        if(b.length > 25) return false; // Cannot be longer than 25 characters
        if(b[0] == 0x20) return false; // Leading space
        if (b[b.length - 1] == 0x20) return false; // Trailing space

        bytes1 lastChar = b[0];

        for(uint i; i<b.length; i++){
            bytes1 char = b[i];

            if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces

            if(
                !(char >= 0x30 && char <= 0x39) && //9-0
                !(char >= 0x41 && char <= 0x5A) && //A-Z
                !(char >= 0x61 && char <= 0x7A) && //a-z
                !(char == 0x20) //space
            )
                return false;

            lastChar = char;
        }

        return true;
    }

    /**
     * @dev Converts the string to lowercase
     */
    function toLower(string memory str) public pure returns (string memory){
        bytes memory bStr = bytes(str);
        bytes memory bLower = new bytes(bStr.length);
        for (uint i = 0; i < bStr.length; i++) {
            // Uppercase character
            if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
                bLower[i] = bytes1(uint8(bStr[i]) + 32);
            } else {
                bLower[i] = bStr[i];
            }
        }
        return string(bLower);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"address","name":"wetAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"maskIndex","type":"uint256"},{"indexed":false,"internalType":"string","name":"newName","type":"string"}],"name":"NameChange","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_NFT_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NAME_CHANGE_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REVEAL_TIMESTAMP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SALE_START_TIMESTAMP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WAIFUS_PROVENANCE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","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":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"string","name":"newName","type":"string"}],"name":"changeName","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"finalizeStartingIndex","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNFTPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"isMintedBeforeReveal","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"nameString","type":"string"}],"name":"isNameReserved","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfNfts","type":"uint256"}],"name":"mintNFT","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"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":[],"name":"startingIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startingIndexBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"string","name":"str","type":"string"}],"name":"toLower","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenNameByIndex","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"validateName","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000076280af9d18a868a0af3dca95b57dde816c1aaf20000000000000000000000000000000000000000000000000000000000000006576169667573000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025746000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): Waifus
Arg [1] : symbol (string): WF
Arg [2] : wetAddress (address): 0x76280AF9D18a868a0aF3dcA95b57DDE816c1aaf2

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 00000000000000000000000076280af9d18a868a0af3dca95b57dde816c1aaf2
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [4] : 5761696675730000000000000000000000000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [6] : 5746000000000000000000000000000000000000000000000000000000000000

45459:22830:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16737:142;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16737:142:0;-1:-1:-1;;;;;;16737:142:0;;:::i;:::-;;;;;;;;;;;;;;;;;;50467:92;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57259:213;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57259:213:0;;:::i;:::-;;;;-1:-1:-1;;;;;57259:213:0;;;;;;;;;;;;;;56803:390;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;56803:390:0;;;;;;;;:::i;:::-;;45848:109;;;;;;;;;;;;;:::i;51753:137::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;51753:137:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;51753:137:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51753:137:0;;-1:-1:-1;51753:137:0;;-1:-1:-1;;;;;51753:137:0:i;51038:203::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;46092:78;;;;;;;;;;;;;:::i;58133:305::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;58133:305:0;;;;;;;;;;;;;;;;;:::i;50808:154::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;50808:154:0;;;;;;;;:::i;56610:131::-;;;;;;;;;;;;;:::i;58509:151::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;58509:151:0;;;;;;;;;;;;;;;;;:::i;51318:164::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51318:164:0;;:::i;46180:61::-;;;;;;;;;;;;;:::i;50231:169::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50231:169:0;;:::i;51555:120::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51555:120:0;;:::i;49954:215::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49954:215:0;-1:-1:-1;;;;;49954:215:0;;:::i;43406:148::-;;;;;;;;;;;;;:::i;54841:691::-;;;;;;;;;;;;;:::i;42764:79::-;;;;;;;;;;;;;:::i;53687:1091::-;;;;;;;;;;;;;;;;-1:-1:-1;53687:1091:0;;:::i;67780:506::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;67780:506:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;67780:506:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67780:506:0;;-1:-1:-1;67780:506:0;;-1:-1:-1;;;;;67780:506:0:i;45966:57::-;;;;;;;;;;;;;:::i;50628:96::-;;;;;;;;;;;;;:::i;66790:918::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;66790:918:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;66790:918:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66790:918:0;;-1:-1:-1;66790:918:0;;-1:-1:-1;;;;;66790:918:0:i;57544:295::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;57544:295:0;;;;;;;;;;:::i;46250:46::-;;;;;;;;;;;;;:::i;58731:285::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;58731:285:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;58731:285:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;58731:285:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58731:285:0;;-1:-1:-1;58731:285:0;;-1:-1:-1;;;;;58731:285:0:i;51984:133::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51984:133:0;;:::i;55607:911::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;55607:911:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;55607:911:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55607:911:0;;-1:-1:-1;55607:911:0;;-1:-1:-1;;;;;55607:911:0:i;46347:28::-;;;;;;;;;;;;;:::i;46305:33::-;;;;;;;;;;;;;:::i;57910:156::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;57910:156:0;;;;;;;;;;:::i;43709:244::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43709:244:0;-1:-1:-1;;;;;43709:244:0;;:::i;52182:1455::-;;;;;;;;;;;;;:::i;16737:142::-;-1:-1:-1;;;;;;16838:33:0;;16814:4;16838:33;;;:20;:33;;;;;;;;16737:142;;;;:::o;50467:92::-;50546:5;50539:12;;;;;;;;-1:-1:-1;;50539:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50513:13;;50539:12;;50546:5;;50539:12;;50546:5;50539:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50467:92;;:::o;57259:213::-;57327:7;57355:16;57363:7;57355;:16::i;:::-;57347:73;;;;-1:-1:-1;;;57347:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57440:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;57440:24:0;;57259:213::o;56803:390::-;56884:13;56900:16;56908:7;56900;:16::i;:::-;56884:32;;56941:5;-1:-1:-1;;;;;56935:11:0;:2;-1:-1:-1;;;;;56935:11:0;;;56927:57;;;;-1:-1:-1;;;56927:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57021:5;-1:-1:-1;;;;;57005:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;57005:21:0;;:62;;;;57030:37;57047:5;57054:12;:10;:12::i;:::-;57030:16;:37::i;:::-;56997:154;;;;-1:-1:-1;;;56997:154:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57164:21;57173:2;57177:7;57164:8;:21::i;:::-;56803:390;;;:::o;45848:109::-;;;;;;;;;;;;;;;;;;;:::o;51753:137::-;51824:4;51848:13;51862:19;51870:10;51862:7;:19::i;:::-;51848:34;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;51848:34:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;51848:34:0;;;;;;;;;;;;;;;;-1:-1:-1;51848:34:0;;;;;;;;;;;;;;51753:137;-1:-1:-1;;;;51753:137:0:o;51038:203::-;51091:7;51212:21;:12;:19;:21::i;:::-;51205:28;;51038:203;:::o;46092:78::-;46135:35;46092:78;:::o;58133:305::-;58294:41;58313:12;:10;:12::i;:::-;58327:7;58294:18;:41::i;:::-;58286:103;;;;-1:-1:-1;;;58286:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58402:28;58412:4;58418:2;58422:7;58402:9;:28::i;50808:154::-;-1:-1:-1;;;;;50924:20:0;;50897:7;50924:20;;;:13;:20;;;;;:30;;50948:5;50924:23;:30::i;:::-;50917:37;;50808:154;;;;;:::o;56610:131::-;42986:12;:10;:12::i;:::-;42976:6;;-1:-1:-1;;;;;42976:6:0;;;:22;;;42968:67;;;;;-1:-1:-1;;;42968:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56705:28:::1;::::0;56673:21:::1;::::0;56705:10:::1;::::0;:28;::::1;;;::::0;56673:21;;56658:12:::1;56705:28:::0;56658:12;56705:28;56673:21;56705:10;:28;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;43046:1;56610:131::o:0;58509:151::-;58613:39;58630:4;58636:2;58640:7;58613:39;;;;;;;;;;;;:16;:39::i;51318:164::-;51385:7;;51427:22;:12;51443:5;51427:15;:22::i;:::-;-1:-1:-1;51405:44:0;51318:164;-1:-1:-1;;;51318:164:0:o;46180:61::-;46224:17;46180:61;:::o;50231:169::-;50295:7;50322:70;50339:7;50322:70;;;;;;;;;;;;;;;;;:12;;:70;:16;:70::i;51555:120::-;51650:17;;;;:10;:17;;;;;;;;;51643:24;;;;;;-1:-1:-1;;51643:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51617:13;;51643:24;;;51650:17;51643:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51555:120;;;:::o;49954:215::-;50018:7;-1:-1:-1;;;;;50046:19:0;;50038:74;;;;-1:-1:-1;;;50038:74:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;50132:20:0;;;;;;:13;:20;;;;;:29;;:27;:29::i;43406:148::-;42986:12;:10;:12::i;:::-;42976:6;;-1:-1:-1;;;;;42976:6:0;;;:22;;;42968:67;;;;;-1:-1:-1;;;42968:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43513:1:::1;43497:6:::0;;43476:40:::1;::::0;-1:-1:-1;;;;;43497:6:0;;::::1;::::0;43476:40:::1;::::0;43513:1;;43476:40:::1;43544:1;43527:19:::0;;-1:-1:-1;;;;;;43527:19:0::1;::::0;;43406:148::o;54841:691::-;54900:13;;:18;54892:60;;;;;-1:-1:-1;;;54892:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;54971:18;;54963:68;;;;;-1:-1:-1;;;54963:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55083:18;;55068:52;55073:29;;55068:52;55052:13;:68;55295:3;;55256:36;;:12;;:16;:36::i;:::-;:42;55252:139;;;46291:5;-1:-1:-1;;55346:12:0;:14;55336:25;55331:48;55315:13;:64;55252:139;55442:13;;55438:87;;55493:13;;:20;;55511:1;55493:17;:20::i;:::-;55477:13;:36;55438:87;54841:691::o;42764:79::-;42802:7;42829:6;-1:-1:-1;;;;;42829:6:0;42764:79;:::o;53687:1091::-;46291:5;53760:13;:11;:13::i;:::-;:30;53752:65;;;;;-1:-1:-1;;;53752:65:0;;;;;;;;;;;;-1:-1:-1;;;53752:65:0;;;;;;;;;;;;;;;53851:1;53836:12;:16;53828:53;;;;;-1:-1:-1;;;53828:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;53916:2;53900:12;:18;;53892:72;;;;-1:-1:-1;;;53892:72:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46291:5;53983:31;54001:12;53983:13;:11;:13::i;:::-;:17;;:31::i;:::-;:49;;53975:84;;;;;-1:-1:-1;;;53975:84:0;;;;;;;;;;;;-1:-1:-1;;;53975:84:0;;;;;;;;;;;;;;;54113:9;54078:31;54096:12;54078:13;:11;:13::i;:::-;:17;;:31::i;:::-;:44;54070:88;;;;;-1:-1:-1;;;54070:88:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;54176:6;54171:270;54192:12;54188:1;:16;54171:270;;;54226:14;54243:13;:11;:13::i;:::-;54226:30;-1:-1:-1;46135:35:0;54275:15;:34;54271:112;;;54330:30;;;;:19;:30;;;;;:37;;-1:-1:-1;;54330:37:0;54363:4;54330:37;;;54271:112;54397:32;54407:10;54419:9;54397;:32::i;:::-;-1:-1:-1;54206:3:0;;54171:270;;;-1:-1:-1;54610:18:0;;:23;:99;;;;;46291:5;54638:13;:11;:13::i;:::-;:31;:70;;;-1:-1:-1;46135:35:0;54673:15;:35;;54638:70;54606:165;;;54747:12;54726:18;:33;54606:165;53687:1091;:::o;67780:506::-;67837:13;67862:17;67888:3;67862:30;;67903:19;67935:4;:11;67925:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67925:22:0;;67903:44;;67963:6;67958:289;67979:4;:11;67975:1;:15;67958:289;;;68071:2;68059:4;68064:1;68059:7;;;;;;;;;;;;;;68053:20;;;;68052:48;;;68097:2;68085:4;68090:1;68085:7;;;;;;;;;;;;;;68079:20;;68052:48;68048:188;;;68146:4;68151:1;68146:7;;;;;;;;;;;;;;;;68140:14;;68157:2;68140:19;68133:27;;68121:6;68128:1;68121:9;;;;;;;;;;;:39;-1:-1:-1;;;;;68121:39:0;;;;;;;;;68048:188;;;68213:4;68218:1;68213:7;;;;;;;;;;;;;;;;68201:6;68208:1;68201:9;;;;;;;;;;;:19;-1:-1:-1;;;;;68201:19:0;;;;;;;;;68048:188;67992:3;;67958:289;;45966:57;46013:10;45966:57;:::o;50628:96::-;50709:7;50702:14;;;;;;;;-1:-1:-1;;50702:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50676:13;;50702:14;;50709:7;;50702:14;;50709:7;50702:14;;;;;;;;;;;;;;;;;;;;;;;;66790:918;66852:4;66868:14;66891:3;66868:27;;66920:1;66909;:8;:12;66906:29;;;66930:5;66923:12;;;;;66906:29;66960:2;66949:1;:8;:13;66946:30;;;66971:5;66964:12;;;;;66946:30;67029:1;67031;67029:4;;;;;;;;;;;;;-1:-1:-1;;;;;;67029:4:0;-1:-1:-1;;;67029:12:0;67026:29;;;67050:5;67043:12;;;;;67026:29;67087:1;67100;67089;:8;:12;67087:15;;;;;;;;;;;;;-1:-1:-1;;;;;;67087:15:0;-1:-1:-1;;;67087:23:0;67083:41;;;67119:5;67112:12;;;;;67083:41;67155:15;67173:1;67175;67173:4;;;;;;;;;;;;-1:-1:-1;;;;;;67173:4:0;;-1:-1:-1;67194:6:0;67190:487;67204:1;:8;67202:1;:10;67190:487;;;67233:11;67247:1;67249;67247:4;;;;;;;;;;;;-1:-1:-1;;;;;;67247:4:0;;-1:-1:-1;;;;67272:12:0;;:32;;;;-1:-1:-1;;;;;;;;;;67288:16:0;;;67272:32;67268:50;;;67313:5;67306:12;;;;;;;;67268:50;-1:-1:-1;;;;;;;;;67393:12:0;;;;;;:28;;-1:-1:-1;;;;;;;;;;67409:12:0;;;;67393:28;67391:31;:89;;;;-1:-1:-1;;;;;;;;;;67451:12:0;;;;;;:28;;-1:-1:-1;;;;;;;;;;67467:12:0;;;;67451:28;67449:31;67391:89;:147;;;;-1:-1:-1;;;;;;;;;;67509:12:0;;;;;;:28;;-1:-1:-1;;;;;;;;;;67525:12:0;;;;67509:28;67507:31;67391:147;:189;;;;-1:-1:-1;;;;;;;;;;67567:12:0;;;67565:15;67391:189;67370:263;;;67628:5;67621:12;;;;;;;;67370:263;67661:4;-1:-1:-1;67214:3:0;;67190:487;;;-1:-1:-1;67696:4:0;;66790:918;-1:-1:-1;;;;66790:918:0:o;57544:295::-;57659:12;:10;:12::i;:::-;-1:-1:-1;;;;;57647:24:0;:8;-1:-1:-1;;;;;57647:24:0;;;57639:62;;;;;-1:-1:-1;;;57639:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;57759:8;57714:18;:32;57733:12;:10;:12::i;:::-;-1:-1:-1;;;;;57714:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;57714:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;57714:53:0;;;;;;;;;;;57798:12;:10;:12::i;:::-;-1:-1:-1;;;;;57783:48:0;;57822:8;57783:48;;;;;;;;;;;;;;;;;;;;57544:295;;:::o;46250:46::-;46291:5;46250:46;:::o;58731:285::-;58863:41;58882:12;:10;:12::i;:::-;58896:7;58863:18;:41::i;:::-;58855:103;;;;-1:-1:-1;;;58855:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58969:39;58983:4;58989:2;58993:7;59002:5;58969:13;:39::i;:::-;58731:285;;;;:::o;51984:133::-;52059:4;52083:26;;;:19;:26;;;;;;;;;51984:133::o;55607:911::-;55685:13;55701:16;55709:7;55701;:16::i;:::-;55685:32;;55754:5;-1:-1:-1;;;;;55738:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;55738:21:0;;55730:65;;;;;-1:-1:-1;;;55730:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;55814:21;55827:7;55814:12;:21::i;:::-;:29;;55839:4;55814:29;55806:62;;;;;-1:-1:-1;;;55806:62:0;;;;;;;;;;;;-1:-1:-1;;;55806:62:0;;;;;;;;;;;;;;;55913:34;55926:10;:19;55937:7;55926:19;;;;;;;;;;;55913:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55913:34:0;55887:22;;;;;;55900:7;;55887:22;;55913:34;55887:22;;;;;;;;;;;;;;;;-1:-1:-1;;55887:22:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;55887:22:0;;;;;;;;;;;;;;;;;;-1:-1:-1;55887:22:0;;-1:-1:-1;;55887:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55887:22:0;:60;;55879:108;;;;-1:-1:-1;;;55879:108:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56006:23;56021:7;56006:14;:23::i;:::-;:32;55998:66;;;;;-1:-1:-1;;;55998:66:0;;;;;;;;;;;;-1:-1:-1;;;55998:66:0;;;;;;;;;;;;;;;56084:11;;56077:78;;;-1:-1:-1;;;56077:78:0;;56110:10;56077:78;;;;56130:4;56077:78;;;;46224:17;56077:78;;;;;;-1:-1:-1;;;;;56084:11:0;;;;56077:32;;:78;;;;;;;;;;;;;;;56084:11;;56077:78;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;56255:1:0;56225:19;;;:10;56077:78;56225:19;;;;56219:33;;-1:-1:-1;;56219:33:0;;;;;;;;;;;:37;56215:115;;56291:19;;;;:10;:19;;;;;;;;;56273:45;;;;;;-1:-1:-1;;56273:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56291:19;56273:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56312:5;56273:17;:45::i;:::-;56340:32;56358:7;56367:4;56340:17;:32::i;:::-;56383:19;;;;:10;:19;;;;;;;;:29;;;;;;;;:::i;:::-;-1:-1:-1;56430:11:0;;56423:43;;;-1:-1:-1;;;56423:43:0;;46224:17;56423:43;;;;;;-1:-1:-1;;;;;56430:11:0;;;;56423:24;;:43;;;;;;;;;;;;;;;56430:11;;56423:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;56482:28:0;;;56423:43;56482:28;;;;;;;;;;;56493:7;;56482:28;;56502:7;;56482:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55607:911;;;:::o;46347:28::-;;;;:::o;46305:33::-;;;;:::o;57910:156::-;-1:-1:-1;;;;;58023:25:0;;;57999:4;58023:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;57910:156::o;43709:244::-;42986:12;:10;:12::i;:::-;42976:6;;-1:-1:-1;;;;;42976:6:0;;;:22;;;42968:67;;;;;-1:-1:-1;;;42968:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;43798:22:0;::::1;43790:73;;;;-1:-1:-1::0;;;43790:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43900:6;::::0;;43879:38:::1;::::0;-1:-1:-1;;;;;43879:38:0;;::::1;::::0;43900:6;::::1;::::0;43879:38:::1;::::0;::::1;43928:6;:17:::0;;-1:-1:-1;;;;;;43928:17:0::1;-1:-1:-1::0;;;;;43928:17:0;;;::::1;::::0;;;::::1;::::0;;43709:244::o;52182:1455::-;52226:7;46013:10;52254:15;:39;;52246:72;;;;;-1:-1:-1;;;52246:72:0;;;;;;;;;;;;-1:-1:-1;;;52246:72:0;;;;;;;;;;;;;;;46291:5;52337:13;:11;:13::i;:::-;:30;52329:65;;;;;-1:-1:-1;;;52329:65:0;;;;;;;;;;;;-1:-1:-1;;;52329:65:0;;;;;;;;;;;;;;;52407:18;52428:13;:11;:13::i;:::-;52407:34;;52475:5;52458:13;:22;52454:1176;;52504:21;52497:28;;;;;52454:1176;52589:5;52572:13;:22;52568:1062;;52618:19;52611:26;;;;;52568:1062;52701:5;52684:13;:22;52680:950;;52730:19;52723:26;;;;;52680:950;52814:5;52797:13;:22;52793:837;;52843:19;52836:26;;;;;52793:837;52926:5;52909:13;:22;52905:725;;52955:18;52948:25;;;;;52905:725;53037:4;53020:13;:21;53016:614;;53065:18;53058:25;;;;;53016:614;53146:4;53129:13;:21;53125:505;;53174:18;53167:25;;;;;53125:505;53254:4;53237:13;:21;53233:397;;53282:18;53275:25;;;;;53233:397;53362:4;53345:13;:21;53341:289;;53390:18;53383:25;;;;;53341:289;53470:4;53453:13;:21;53449:181;;53498:18;53491:25;;;;;53449:181;53579:18;53572:25;;;;;53449:181;52182:1455;;:::o;60483:119::-;60540:4;60564:30;:12;60586:7;60564:21;:30::i;5905:106::-;5993:10;5905:106;:::o;65550:158::-;65616:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;65616:29:0;-1:-1:-1;;;;;65616:29:0;;;;;;;;:24;;65670:16;65616:24;65670:7;:16::i;:::-;-1:-1:-1;;;;;65661:39:0;;;;;;;;;;;65550:158;;:::o;32967:123::-;33036:7;33063:19;33071:3;33063:7;:19::i;60769:333::-;60854:4;60879:16;60887:7;60879;:16::i;:::-;60871:73;;;;-1:-1:-1;;;60871:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60955:13;60971:16;60979:7;60971;:16::i;:::-;60955:32;;61017:5;-1:-1:-1;;;;;61006:16:0;:7;-1:-1:-1;;;;;61006:16:0;;:51;;;;61050:7;-1:-1:-1;;;;;61026:31:0;:20;61038:7;61026:11;:20::i;:::-;-1:-1:-1;;;;;61026:31:0;;61006:51;:87;;;;61061:32;61078:5;61085:7;61061:16;:32::i;:::-;60998:96;60769:333;-1:-1:-1;;;;60769:333:0:o;63797:574::-;63915:4;-1:-1:-1;;;;;63895:24:0;:16;63903:7;63895;:16::i;:::-;-1:-1:-1;;;;;63895:24:0;;63887:78;;;;-1:-1:-1;;;63887:78:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;63984:16:0;;63976:65;;;;-1:-1:-1;;;63976:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64054:39;64075:4;64081:2;64085:7;64054:20;:39::i;:::-;64158:29;64175:1;64179:7;64158:8;:29::i;:::-;-1:-1:-1;;;;;64200:19:0;;;;;;:13;:19;;;;;:35;;64227:7;64200:26;:35::i;:::-;-1:-1:-1;;;;;;64246:17:0;;;;;;:13;:17;;;;;:30;;64268:7;64246:21;:30::i;:::-;-1:-1:-1;64289:29:0;:12;64306:7;64315:2;64289:16;:29::i;:::-;;64355:7;64351:2;-1:-1:-1;;;;;64336:27:0;64345:4;-1:-1:-1;;;;;64336:27:0;;;;;;;;;;;63797:574;;;:::o;42128:137::-;42199:7;42234:22;42238:3;42250:5;42234:3;:22::i;33429:227::-;33509:7;;;;33569:22;33573:3;33585:5;33569:3;:22::i;:::-;33538:53;;;;-1:-1:-1;33429:227:0;-1:-1:-1;;;;;33429:227:0:o;34091:204::-;34198:7;34241:44;34246:3;34266;34272:12;34241:4;:44::i;:::-;34233:53;-1:-1:-1;34091:204:0;;;;;;:::o;1366:136::-;1424:7;1451:43;1455:1;1458;1451:43;;;;;;;;;;;;;;;;;:3;:43::i;902:181::-;960:7;992:5;;;1016:6;;;;1008:46;;;;;-1:-1:-1;;;1008:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;2256:471;2314:7;2559:6;2555:47;;-1:-1:-1;2589:1:0;2582:8;;2555:47;2626:5;;;2630:1;2626;:5;:1;2650:5;;;;;:10;2642:56;;;;-1:-1:-1;;;2642:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61445:153;61545:5;61529:13;:11;:13::i;:::-;:21;61521:30;;;;;;61562:26;61572:2;61576:7;61562:26;;;;;;;;;;;;:9;:26::i;59898:272::-;60012:28;60022:4;60028:2;60032:7;60012:9;:28::i;:::-;60059:48;60082:4;60088:2;60092:7;60101:5;60059:22;:48::i;:::-;60051:111;;;;-1:-1:-1;;;60051:111:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66528:129;66640:9;66610:13;66624:12;66632:3;66624:7;:12::i;:::-;66610:27;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;66610:27:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;66610:27:0;;;;;;;;;;;;;;;;-1:-1:-1;66610:27:0;;;;;;;;;;:39;;-1:-1:-1;;66610:39:0;;;;;;;;;;;-1:-1:-1;;;;66528:129:0:o;32728:151::-;32812:4;32836:35;32846:3;32866;32836:9;:35::i;30350:110::-;30433:19;;30350:110::o;41215:137::-;41285:4;41309:35;41317:3;41337:5;41309:7;:35::i;40908:131::-;40975:4;40999:32;41004:3;41024:5;40999:4;:32::i;32160:176::-;32249:4;32273:55;32278:3;32298;-1:-1:-1;;;;;32312:14:0;;32273:4;:55::i;38792:204::-;38887:18;;38859:7;;38887:26;-1:-1:-1;38879:73:0;;;;-1:-1:-1;;;38879:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38970:3;:11;;38982:5;38970:18;;;;;;;;;;;;;;;;38963:25;;38792:204;;;;:::o;30815:279::-;30919:19;;30882:7;;;;30919:27;-1:-1:-1;30911:74:0;;;;-1:-1:-1;;;30911:74:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30998:22;31023:3;:12;;31036:5;31023:19;;;;;;;;;;;;;;;;;;30998:44;;31061:5;:10;;;31073:5;:12;;;31053:33;;;;;30815:279;;;;;:::o;31517:319::-;31611:7;31650:17;;;:12;;;:17;;;;;;31701:12;31686:13;31678:36;;;;-1:-1:-1;;;31678:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31768:3;:12;;31792:1;31781:8;:12;31768:26;;;;;;;;;;;;;;;;;;:33;;;31761:40;;;31517:319;;;;;:::o;1805:192::-;1891:7;1927:12;1919:6;;;;1911:29;;;;-1:-1:-1;;;1911:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1963:5:0;;;1805:192::o;61825:291::-;61921:18;61927:2;61931:7;61921:5;:18::i;:::-;61974:5;61958:13;:11;:13::i;:::-;:21;61950:30;;;;;;61999:54;62030:1;62034:2;62038:7;62047:5;61999:22;:54::i;:::-;61991:117;;;;-1:-1:-1;;;61991:117:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64938:604;65059:4;65086:15;:2;-1:-1:-1;;;;;65086:13:0;;:15::i;:::-;65081:60;;-1:-1:-1;65125:4:0;65118:11;;65081:60;65151:23;65177:252;-1:-1:-1;;;65290:12:0;:10;:12::i;:::-;65317:4;65336:7;65358:5;65193:181;;;;;;-1:-1:-1;;;;;65193:181:0;;;;;;-1:-1:-1;;;;;65193:181:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;65193:181:0;;;;;;;-1:-1:-1;;;;;65193:181:0;;;;;;;;;;;65177:252;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;65177:15:0;;;:252;:15;:252::i;:::-;65151:278;;65440:13;65467:10;65456:32;;;;;;;;;;;;;;;-1:-1:-1;65456:32:0;-1:-1:-1;;;;;;65507:26:0;-1:-1:-1;;;65507:26:0;;-1:-1:-1;;;64938:604:0;;;;;;:::o;30130:125::-;30201:4;30225:17;;;:12;;;;;:17;;;;;;:22;;;30130:125::o;36494:1544::-;36560:4;36699:19;;;:12;;;:19;;;;;;36735:15;;36731:1300;;37170:18;;-1:-1:-1;;37121:14:0;;;;37170:22;;;;37097:21;;37170:3;;:22;;37457;;;;;;;;;;;;;;37437:42;;37603:9;37574:3;:11;;37586:13;37574:26;;;;;;;;;;;;;;;;;;;:38;;;;37680:23;;;37722:1;37680:12;;;:23;;;;;;37706:17;;;37680:43;;37832:17;;37680:3;;37832:17;;;;;;;;;;;;;;;;;;;;;;37927:3;:12;;:19;37940:5;37927:19;;;;;;;;;;;37920:26;;;37970:4;37963:11;;;;;;;;36731:1300;38014:5;38007:12;;;;;35904:414;35967:4;35989:21;35999:3;36004:5;35989:9;:21::i;:::-;35984:327;;-1:-1:-1;36027:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;36210:18;;36188:19;;;:12;;;:19;;;;;;:40;;;;36243:11;;35984:327;-1:-1:-1;36294:5:0;36287:12;;27630:692;27706:4;27841:17;;;:12;;;:17;;;;;;27875:13;27871:444;;-1:-1:-1;;27960:38:0;;;;;;;;;;;;;;;;;;27942:57;;;;;;;;:12;:57;;;;;;;;;;;;;;;;;;;;;;;;28157:19;;28137:17;;;:12;;;:17;;;;;;;:39;28191:11;;27871:444;28271:5;28235:3;:12;;28259:1;28248:8;:12;28235:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;28298:5;28291:12;;;;;62452:404;-1:-1:-1;;;;;62532:16:0;;62524:61;;;;;-1:-1:-1;;;62524:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62605:16;62613:7;62605;:16::i;:::-;62604:17;62596:58;;;;;-1:-1:-1;;;62596:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;62667:45;62696:1;62700:2;62704:7;62667:20;:45::i;:::-;-1:-1:-1;;;;;62725:17:0;;;;;;:13;:17;;;;;:30;;62747:7;62725:21;:30::i;:::-;-1:-1:-1;62768:29:0;:12;62785:7;62794:2;62768:16;:29::i;:::-;-1:-1:-1;62815:33:0;;62840:7;;-1:-1:-1;;;;;62815:33:0;;;62832:1;;62815:33;;62832:1;;62815:33;62452:404;;:::o;7844:422::-;8211:20;8250:8;;;7844:422::o;10762:195::-;10865:12;10897:52;10919:6;10927:4;10933:1;10936:12;10865;12066:18;12077:6;12066:10;:18::i;:::-;12058:60;;;;;-1:-1:-1;;;12058:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;12192:12;12206:23;12233:6;-1:-1:-1;;;;;12233:11:0;12253:5;12261:4;12233:33;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;12233:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12191:75;;;;12284:52;12302:7;12311:10;12323:12;12284:17;:52::i;:::-;12277:59;11814:530;-1:-1:-1;;;;;;;11814:530:0:o;14354:742::-;14469:12;14498:7;14494:595;;;-1:-1:-1;14529:10:0;14522:17;;14494:595;14643:17;;:21;14639:439;;14906:10;14900:17;14967:15;14954:10;14950:2;14946:19;14939:44;14854:148;15042:20;;-1:-1:-1;;;15042:20:0;;;;;;;;;;;;;;;;;15049:12;;15042:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

ipfs://354e746c4b6940b8afd34f9338faa4fec5a3b8549d904fe5ffea2bf9ec05a927