Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

library Math    - function max(uint256 a, uint256 b)    - function min(uint256 a, uint256 b)    - function average(uint256 a, uint256 b ...    - function ceilDiv(uint256 a, uint256 b ...    - function mulDiv(    - function mulDiv(    - function sqrt(uint256 a)    - function sqrt(uint256 a, Rounding rou ...    - function log2(uint256 value)    - function log2(uint256 value, Rounding ...    - function log10(uint256 value)    - function log10(uint256 value, Roundin ...    - function log256(uint256 value)    - function log256(uint256 value, Roundi ... library Strings    - function toString(uint256 value)    - function toHexString(uint256 value)    - function toHexString(uint256 value, u ...    - function toHexString(address addr) library Address    - function isContract(address account)    - function sendValue(address payable re ...    - function functionCall(address target, ...    - function functionCall(    - function functionCallWithValue(    - function functionCallWithValue(    - function functionStaticCall(address t ...    - function functionStaticCall(    - function functionDelegateCall(address ...    - function functionDelegateCall(    - function verifyCallResultFromTarget(    - function verifyCallResult(    - function _revert(bytes memory returnd ... interface IERC721Receiver    - function onERC721Received( interface IERC165    - function supportsInterface(bytes4 int ...    - function supportsInterface(bytes4 int ... interface IERC721 is IERC165    - function balanceOf(address owner)    - function ownerOf(uint256 tokenId)    - function safeTransferFrom(    - function safeTransferFrom(    - function transferFrom(    - function approve(address to, uint256 ...    - function setApprovalForAll(address op ...    - function getApproved(uint256 tokenId)    - function isApprovedForAll(address own ... interface IERC721Metadata is IERC721    - function name()    - function symbol()    - function tokenURI(uint256 tokenId)    - function _msgSender()    - function _msgData()  contract ERC721 is Context, ERC165 ...    - function supportsInterface(bytes4 int ...    - function balanceOf(address owner)    - function ownerOf(uint256 tokenId)    - function name()    - function symbol()    - function tokenURI(uint256 tokenId)    - function _baseURI()    - function approve(address to, uint256 ...    - function getApproved(uint256 tokenId)    - function setApprovalForAll(address op ...    - function isApprovedForAll(address own ...    - function transferFrom(    - function safeTransferFrom(    - function safeTransferFrom(    - function _safeTransfer(    - function _ownerOf(uint256 tokenId)    - function _exists(uint256 tokenId)    - function _isApprovedOrOwner(address s ...    - function _safeMint(address to, uint25 ...    - function _safeMint(    - function _mint(address to, uint256 to ...    - function _burn(uint256 tokenId)    - function _transfer(    - function _approve(address to, uint256 ...    - function _setApprovalForAll(    - function _requireMinted(uint256 token ...    - function _checkOnERC721Received(    - function _beforeTokenTransfer(    - function _afterTokenTransfer(    - function owner()    - function _checkOwner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ...  contract ANON is Ownable, ERC721 *    - function setBaseURI(string calldata b ...    - function setPaused()    - function setKobaAddress(address _koba ...    - function withdraw()    - function manualRevealKoba(uint256[] c ...    - function tokenURI(uint256 tokenId)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-01-13
*/

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


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

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


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;


/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

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


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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");

        (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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

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


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

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

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


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

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


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

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


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * 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;

    /**
     * @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 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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * 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 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 the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

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


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;


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

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

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

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


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

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


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;








/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

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

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: address zero is not a valid owner");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _ownerOf(tokenId);
        require(owner != address(0), "ERC721: invalid token ID");
        return owner;
    }

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        _requireMinted(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

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

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

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        _requireMinted(tokenId);

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or 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: caller is not token owner or 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 the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

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

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

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

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

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

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

        // Check that tokenId was not minted by `_beforeTokenTransfer` hook
        require(!_exists(tokenId), "ERC721: token already minted");

        unchecked {
            // Will not overflow unless all 2**256 token ids are minted to the same owner.
            // Given that tokens are minted one by one, it is impossible in practice that
            // this ever happens. Might change if we allow batch minting.
            // The ERC fails to describe this case.
            _balances[to] += 1;
        }

        _owners[tokenId] = to;

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

        _afterTokenTransfer(address(0), to, tokenId, 1);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

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

        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
        owner = ERC721.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        unchecked {
            // Cannot overflow, as that would require more tokens to be burned/transferred
            // out than the owner initially received through minting and transferring in.
            _balances[owner] -= 1;
        }
        delete _owners[tokenId];

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

        _afterTokenTransfer(owner, address(0), tokenId, 1);
    }

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

        _beforeTokenTransfer(from, to, tokenId, 1);

        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");

        // Clear approvals from the previous owner
        delete _tokenApprovals[tokenId];

        unchecked {
            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
            // `from`'s balance is the number of token held, which is at least one before the current
            // transfer.
            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
            // all 2**256 token ids to be minted, which in practice is impossible.
            _balances[from] -= 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId, 1);
    }

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

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @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()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
     * - When `from` is zero, the tokens will be minted for `to`.
     * - When `to` is zero, ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256, /* firstTokenId */
        uint256 batchSize
    ) internal virtual {
        if (batchSize > 1) {
            if (from != address(0)) {
                _balances[from] -= batchSize;
            }
            if (to != address(0)) {
                _balances[to] += batchSize;
            }
        }
    }

    /**
     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
     * - When `from` is zero, the tokens were minted for `to`.
     * - When `to` is zero, ``from``'s tokens were burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual {}
}

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


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


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

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        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 {
        _transferOwnership(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");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: ANONbyANON.sol



pragma solidity ^0.8.0;





contract ANON is Ownable, ERC721 {  
    using Strings for uint256;
    
    string private _baseURIextended;
    bool public pauseMint;
    IERC721 public koba;

    address public constant burnAddress = 0x000000000000000000000000000000000000dEaD;

    constructor(address _koba) ERC721("ANON by ANON", "ANON") {
        pauseMint = true;
        koba = IERC721(_koba);
    }

    function setBaseURI(string calldata baseURI_) external onlyOwner {
        _baseURIextended = baseURI_;
    }

    function setPaused() external onlyOwner {
        pauseMint = !pauseMint;
    }

    function setKobaAddress(address _koba) external onlyOwner {
        koba = IERC721(_koba);
    }

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

    function manualRevealKoba(uint256[] calldata _kobaIds) external {
        require(!pauseMint, "Paused!");
        require(_kobaIds.length > 0, "ids length is zero.");
        
        for(uint256 i = 0; i < _kobaIds.length; i++) {
            require(koba.ownerOf(_kobaIds[i]) == msg.sender, "Not Your NFT.");
            koba.transferFrom(address(msg.sender), burnAddress, _kobaIds[i]);
            _safeMint(msg.sender, _kobaIds[i]);
        }
    }

    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
        return bytes(_baseURIextended).length > 0 ? string(abi.encodePacked(_baseURIextended, tokenId.toString(), ".json")) : "";
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_koba","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"koba","outputs":[{"internalType":"contract IERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_kobaIds","type":"uint256[]"}],"name":"manualRevealKoba","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pauseMint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_koba","type":"address"}],"name":"setKobaAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000deeddaa9bc54ec631eb83f0cc8406ff163837168

-----Decoded View---------------
Arg [0] : _koba (address): 0xDEEDdAa9Bc54ec631EB83F0Cc8406ff163837168

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000deeddaa9bc54ec631eb83f0cc8406ff163837168

54483:1691:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35877:305;;;;;;:::i;:::-;;:::i;:::-;;;8416:14:1;;8409:22;8391:41;;8379:2;8364:18;35877:305:0;;;;;;;;36805:100;;;:::i;:::-;;;;;;;:::i;38317:171::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;7334:32:1;;;7316:51;;7304:2;7289:18;38317:171:0;7170:203:1;37835:416:0;;;;;;:::i;:::-;;:::i;:::-;;39017:335;;;;;;:::i;:::-;;:::i;54998:81::-;;;:::i;55193:196::-;;;:::i;39423:185::-;;;;;;:::i;:::-;;:::i;55087:98::-;;;;;;:::i;:::-;;:::i;54879:111::-;;;;;;:::i;:::-;;:::i;36515:223::-;;;;;;:::i;:::-;;:::i;36246:207::-;;;;;;:::i;:::-;;:::i;:::-;;;15557:25:1;;;15545:2;15530:18;36246:207:0;15411:177:1;54657:80:0;;54695:42;54657:80;;53600:103;;;:::i;54629:19::-;;;;;;;;-1:-1:-1;;;;;54629:19:0;;;52952:87;52998:7;53025:6;-1:-1:-1;;;;;53025:6:0;52952:87;;36974:104;;;:::i;55397:460::-;;;;;;:::i;:::-;;:::i;38560:155::-;;;;;;:::i;:::-;;:::i;39679:322::-;;;;;;:::i;:::-;;:::i;55865:306::-;;;;;;:::i;:::-;;:::i;54601:21::-;;;;;;;;;38786:164;;;;;;:::i;:::-;-1:-1:-1;;;;;38907:25:0;;;38883:4;38907:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;38786:164;53858:201;;;;;;:::i;:::-;;:::i;35877:305::-;35979:4;-1:-1:-1;;;;;;36016:40:0;;-1:-1:-1;;;36016:40:0;;:105;;-1:-1:-1;;;;;;;36073:48:0;;-1:-1:-1;;;36073:48:0;36016:105;:158;;;-1:-1:-1;;;;;;;;;;27605:40:0;;;36138:36;35996:178;35877:305;-1:-1:-1;;35877:305:0:o;36805:100::-;36859:13;36892:5;36885:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36805:100;:::o;38317:171::-;38393:7;38413:23;38428:7;38413:14;:23::i;:::-;-1:-1:-1;38456:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;38456:24:0;;38317:171::o;37835:416::-;37916:13;37932:23;37947:7;37932:14;:23::i;:::-;37916:39;;37980:5;-1:-1:-1;;;;;37974:11:0;:2;-1:-1:-1;;;;;37974:11:0;;;37966:57;;;;-1:-1:-1;;;37966:57:0;;14781:2:1;37966:57:0;;;14763:21:1;14820:2;14800:18;;;14793:30;14859:34;14839:18;;;14832:62;-1:-1:-1;;;14910:18:1;;;14903:31;14951:19;;37966:57:0;;;;;;;;;34336:10;-1:-1:-1;;;;;38058:21:0;;;;:62;;-1:-1:-1;38083:37:0;38100:5;34336:10;38786:164;:::i;38083:37::-;38036:173;;;;-1:-1:-1;;;38036:173:0;;15183:2:1;38036:173:0;;;15165:21:1;15222:2;15202:18;;;15195:30;15261:34;15241:18;;;15234:62;15332:31;15312:18;;;15305:59;15381:19;;38036:173:0;14981:425:1;38036:173:0;38222:21;38231:2;38235:7;38222:8;:21::i;:::-;37905:346;37835:416;;:::o;39017:335::-;39212:41;34336:10;39245:7;39212:18;:41::i;:::-;39204:99;;;;-1:-1:-1;;;39204:99:0;;;;;;;:::i;:::-;39316:28;39326:4;39332:2;39336:7;39316:9;:28::i;54998:81::-;52838:13;:11;:13::i;:::-;55062:9:::1;::::0;;-1:-1:-1;;55049:22:0;::::1;55062:9;::::0;;::::1;55061:10;55049:22;::::0;;54998:81::o;55193:196::-;52838:13;:11;:13::i;:::-;55351:30:::1;::::0;55258:21:::1;::::0;55329:10:::1;::::0;;;55351:30;::::1;;;::::0;55258:21;;55243:12:::1;55351:30:::0;55243:12;55351:30;55258:21;55329:10;55351:30;::::1;;;;;;;;;;;;;::::0;::::1;;;;39423:185:::0;39561:39;39578:4;39584:2;39588:7;39561:39;;;;;;;;;;;;:16;:39::i;55087:98::-;52838:13;:11;:13::i;:::-;55156:4:::1;:21:::0;;-1:-1:-1;;;;;55156:21:0;;::::1;;;-1:-1:-1::0;;;;;;55156:21:0;;::::1;::::0;;;::::1;::::0;;55087:98::o;54879:111::-;52838:13;:11;:13::i;:::-;54955:27:::1;:16;54974:8:::0;;54955:27:::1;:::i;36515:223::-:0;36587:7;41402:16;;;:7;:16;;;;;;-1:-1:-1;;;;;41402:16:0;;36651:56;;;;-1:-1:-1;;;36651:56:0;;14428:2:1;36651:56:0;;;14410:21:1;14467:2;14447:18;;;14440:30;-1:-1:-1;;;14486:18:1;;;14479:54;14550:18;;36651:56:0;14226:348:1;36246:207:0;36318:7;-1:-1:-1;;;;;36346:19:0;;36338:73;;;;-1:-1:-1;;;36338:73:0;;12538:2:1;36338:73:0;;;12520:21:1;12577:2;12557:18;;;12550:30;12616:34;12596:18;;;12589:62;-1:-1:-1;;;12667:18:1;;;12660:39;12716:19;;36338:73:0;12336:405:1;36338:73:0;-1:-1:-1;;;;;;36429:16:0;;;;;:9;:16;;;;;;;36246:207::o;53600:103::-;52838:13;:11;:13::i;:::-;53665:30:::1;53692:1;53665:18;:30::i;:::-;53600:103::o:0;36974:104::-;37030:13;37063:7;37056:14;;;;;:::i;55397:460::-;55481:9;;;;55480:10;55472:30;;;;-1:-1:-1;;;55472:30:0;;12203:2:1;55472:30:0;;;12185:21:1;12242:1;12222:18;;;12215:29;-1:-1:-1;;;12260:18:1;;;12253:37;12307:18;;55472:30:0;12001:330:1;55472:30:0;55521:19;55513:51;;;;-1:-1:-1;;;55513:51:0;;9093:2:1;55513:51:0;;;9075:21:1;9132:2;9112:18;;;9105:30;-1:-1:-1;;;9151:18:1;;;9144:49;9210:18;;55513:51:0;8891:343:1;55513:51:0;55589:9;55585:265;55604:19;;;55585:265;;;55653:4;;55682:10;;55653:4;;;-1:-1:-1;;;;;55653:4:0;:12;55666:8;;55675:1;55666:11;;;;;;;:::i;:::-;;;;;;;55653:25;;;;;;;;;;;;;15557::1;;15545:2;15530:18;;15411:177;55653:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;55653:39:0;;55645:65;;;;-1:-1:-1;;;55645:65:0;;13309:2:1;55645:65:0;;;13291:21:1;13348:2;13328:18;;;13321:30;-1:-1:-1;;;13367:18:1;;;13360:43;13420:18;;55645:65:0;13107:337:1;55645:65:0;55725:4;;;;;-1:-1:-1;;;;;55725:4:0;:17;55751:10;54695:42;55777:8;;55786:1;55777:11;;;;;;;:::i;:::-;55725:64;;-1:-1:-1;;;;;;55725:64:0;;;;;;;-1:-1:-1;;;;;7636:15:1;;;55725:64:0;;;7618:34:1;7688:15;;;;7668:18;;;7661:43;-1:-1:-1;55777:11:0;;;;;;7720:18:1;;;7713:34;7553:18;;55725:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55804:34;55814:10;55826:8;;55835:1;55826:11;;;;;;;:::i;:::-;;;;;;;55804:9;:34::i;:::-;55625:3;;;;:::i;:::-;;;;55585:265;;38560:155;38655:52;34336:10;38688:8;38698;38655:18;:52::i;:::-;38560:155;;:::o;39679:322::-;39853:41;34336:10;39886:7;39853:18;:41::i;:::-;39845:99;;;;-1:-1:-1;;;39845:99:0;;;;;;;:::i;:::-;39955:38;39969:4;39975:2;39979:7;39988:4;39955:13;:38::i;:::-;39679:322;;;;:::o;55865:306::-;41804:4;41402:16;;;:7;:16;;;;;;55930:13;;-1:-1:-1;;;;;41402:16:0;55956:76;;;;-1:-1:-1;;;55956:76:0;;14012:2:1;55956:76:0;;;13994:21:1;14051:2;14031:18;;;14024:30;14090:34;14070:18;;;14063:62;-1:-1:-1;;;14141:18:1;;;14134:45;14196:19;;55956:76:0;13810:411:1;55956:76:0;56083:1;56056:16;56050:30;;;;;:::i;:::-;;;:34;:113;;;;;;;;;;;;;;;;;56111:16;56129:18;:7;:16;:18::i;:::-;56094:63;;;;;;;;;:::i;:::-;;;;;;;;;;;;;56043:120;55865:306;-1:-1:-1;;55865:306:0:o;53858:201::-;52838:13;:11;:13::i;:::-;-1:-1:-1;;;;;53947:22:0;::::1;53939:73;;;::::0;-1:-1:-1;;;53939:73:0;;10274:2:1;53939:73:0::1;::::0;::::1;10256:21:1::0;10313:2;10293:18;;;10286:30;10352:34;10332:18;;;10325:62;-1:-1:-1;;;10403:18:1;;;10396:36;10449:19;;53939:73:0::1;10072:402:1::0;53939:73:0::1;54023:28;54042:8;54023:18;:28::i;:::-;53858:201:::0;:::o;48136:135::-;41804:4;41402:16;;;:7;:16;;;;;;-1:-1:-1;;;;;41402:16:0;48210:53;;;;-1:-1:-1;;;48210:53:0;;14428:2:1;48210:53:0;;;14410:21:1;14467:2;14447:18;;;14440:30;-1:-1:-1;;;14486:18:1;;;14479:54;14550:18;;48210:53:0;14226:348:1;47415:174:0;47490:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;47490:29:0;-1:-1:-1;;;;;47490:29:0;;;;;;;;:24;;47544:23;47490:24;47544:14;:23::i;:::-;-1:-1:-1;;;;;47535:46:0;;;;;;;;;;;47415:174;;:::o;42034:264::-;42127:4;42144:13;42160:23;42175:7;42160:14;:23::i;:::-;42144:39;;42213:5;-1:-1:-1;;;;;42202:16:0;:7;-1:-1:-1;;;;;42202:16:0;;:52;;;-1:-1:-1;;;;;;38907:25:0;;;38883:4;38907:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;42222:32;42202:87;;;;42282:7;-1:-1:-1;;;;;42258:31:0;:20;42270:7;42258:11;:20::i;:::-;-1:-1:-1;;;;;42258:31:0;;42202:87;42194:96;42034:264;-1:-1:-1;;;;42034:264:0:o;46033:1263::-;46192:4;-1:-1:-1;;;;;46165:31:0;:23;46180:7;46165:14;:23::i;:::-;-1:-1:-1;;;;;46165:31:0;;46157:81;;;;-1:-1:-1;;;46157:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;46257:16:0;;46249:65;;;;-1:-1:-1;;;46249:65:0;;11444:2:1;46249:65:0;;;11426:21:1;11483:2;11463:18;;;11456:30;11522:34;11502:18;;;11495:62;-1:-1:-1;;;11573:18:1;;;11566:34;11617:19;;46249:65:0;11242:400:1;46249:65:0;46327:42;46348:4;46354:2;46358:7;46367:1;46327:20;:42::i;:::-;46499:4;-1:-1:-1;;;;;46472:31:0;:23;46487:7;46472:14;:23::i;:::-;-1:-1:-1;;;;;46472:31:0;;46464:81;;;;-1:-1:-1;;;46464:81:0;;;;;;;:::i;:::-;46617:24;;;;:15;:24;;;;;;;;46610:31;;-1:-1:-1;;;;;;46610:31:0;;;;;;-1:-1:-1;;;;;47093:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;47093:20:0;;;47128:13;;;;;;;;;:18;;46610:31;47128:18;;;47168:16;;;:7;:16;;;;;;:21;;;;;;;;;;47207:27;;46633:7;;47207:27;;;37905:346;37835:416;;:::o;53117:132::-;52998:7;53025:6;-1:-1:-1;;;;;53025:6:0;34336:10;53181:23;53173:68;;;;-1:-1:-1;;;53173:68:0;;13651:2:1;53173:68:0;;;13633:21:1;;;13670:18;;;13663:30;13729:34;13709:18;;;13702:62;13781:18;;53173:68:0;13449:356:1;54219:191:0;54293:16;54312:6;;-1:-1:-1;;;;;54329:17:0;;;-1:-1:-1;;;;;;54329:17:0;;;;;;54362:40;;54312:6;;;;;;;54362:40;;54293:16;54362:40;54282:128;54219:191;:::o;42640:110::-;42716:26;42726:2;42730:7;42716:26;;;;;;;;;;;;:9;:26::i;47732:315::-;47887:8;-1:-1:-1;;;;;47878:17:0;:5;-1:-1:-1;;;;;47878:17:0;;;47870:55;;;;-1:-1:-1;;;47870:55:0;;11849:2:1;47870:55:0;;;11831:21:1;11888:2;11868:18;;;11861:30;11927:27;11907:18;;;11900:55;11972:18;;47870:55:0;11647:349:1;47870:55:0;-1:-1:-1;;;;;47936:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;47936:46:0;;;;;;;;;;47998:41;;8391::1;;;47998::0;;8364:18:1;47998:41:0;;;;;;;47732:315;;;:::o;40882:313::-;41038:28;41048:4;41054:2;41058:7;41038:9;:28::i;:::-;41085:47;41108:4;41114:2;41118:7;41127:4;41085:22;:47::i;:::-;41077:110;;;;-1:-1:-1;;;41077:110:0;;;;;;;:::i;13338:716::-;13394:13;13445:14;13462:17;13473:5;13462:10;:17::i;:::-;13482:1;13462:21;13445:38;;13498:20;13532:6;13521:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;13521:18:0;-1:-1:-1;13498:41:0;-1:-1:-1;13663:28:0;;;13679:2;13663:28;13720:288;-1:-1:-1;;13752:5:0;-1:-1:-1;;;13889:2:0;13878:14;;13873:30;13752:5;13860:44;13950:2;13941:11;;;-1:-1:-1;13975:10:0;13971:21;;13987:5;;13971:21;13720:288;;;-1:-1:-1;14029:6:0;13338:716;-1:-1:-1;;;13338:716:0:o;50420:410::-;50610:1;50598:9;:13;50594:229;;;-1:-1:-1;;;;;50632:18:0;;;50628:87;;-1:-1:-1;;;;;50671:15:0;;;;;;:9;:15;;;;;:28;;50690:9;;50671:15;:28;;50690:9;;50671:28;:::i;:::-;;;;-1:-1:-1;;50628:87:0;-1:-1:-1;;;;;50733:16:0;;;50729:83;;-1:-1:-1;;;;;50770:13:0;;;;;;:9;:13;;;;;:26;;50787:9;;50770:13;:26;;50787:9;;50770:26;:::i;:::-;;;;-1:-1:-1;;50420:410:0;;;;:::o;42977:319::-;43106:18;43112:2;43116:7;43106:5;:18::i;:::-;43157:53;43188:1;43192:2;43196:7;43205:4;43157:22;:53::i;:::-;43135:153;;;;-1:-1:-1;;;43135:153:0;;;;;;;:::i;48835:853::-;48989:4;-1:-1:-1;;;;;49010:13:0;;16760:19;:23;49006:675;;49046:71;;-1:-1:-1;;;49046:71:0;;-1:-1:-1;;;;;49046:36:0;;;;;:71;;34336:10;;49097:4;;49103:7;;49112:4;;49046:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49046:71:0;;;;;;;;-1:-1:-1;;49046:71:0;;;;;;;;;;;;:::i;:::-;;;49042:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49287:13:0;;49283:328;;49330:60;;-1:-1:-1;;;49330:60:0;;;;;;;:::i;49283:328::-;49561:6;49555:13;49546:6;49542:2;49538:15;49531:38;49042:584;-1:-1:-1;;;;;;49168:51:0;-1:-1:-1;;;49168:51:0;;-1:-1:-1;49161:58:0;;49006:675;-1:-1:-1;49665:4:0;48835:853;;;;;;:::o;10204:922::-;10257:7;;-1:-1:-1;;;10335:15:0;;10331:102;;-1:-1:-1;;;10371:15:0;;;-1:-1:-1;10415:2:0;10405:12;10331:102;10460:6;10451:5;:15;10447:102;;10496:6;10487:15;;;-1:-1:-1;10531:2:0;10521:12;10447:102;10576:6;10567:5;:15;10563:102;;10612:6;10603:15;;;-1:-1:-1;10647:2:0;10637:12;10563:102;10692:5;10683;:14;10679:99;;10727:5;10718:14;;;-1:-1:-1;10761:1:0;10751:11;10679:99;10805:5;10796;:14;10792:99;;10840:5;10831:14;;;-1:-1:-1;10874:1:0;10864:11;10792:99;10918:5;10909;:14;10905:99;;10953:5;10944:14;;;-1:-1:-1;10987:1:0;10977:11;10905:99;11031:5;11022;:14;11018:66;;11067:1;11057:11;11112:6;10204:922;-1:-1:-1;;10204:922:0:o;43632:942::-;-1:-1:-1;;;;;43712:16:0;;43704:61;;;;-1:-1:-1;;;43704:61:0;;12948:2:1;43704:61:0;;;12930:21:1;;;12967:18;;;12960:30;13026:34;13006:18;;;12999:62;13078:18;;43704:61:0;12746:356:1;43704:61:0;41804:4;41402:16;;;:7;:16;;;;;;-1:-1:-1;;;;;41402:16:0;41828:31;43776:58;;;;-1:-1:-1;;;43776:58:0;;11087:2:1;43776:58:0;;;11069:21:1;11126:2;11106:18;;;11099:30;11165;11145:18;;;11138:58;11213:18;;43776:58:0;10885:352:1;43776:58:0;43847:48;43876:1;43880:2;43884:7;43893:1;43847:20;:48::i;:::-;41804:4;41402:16;;;:7;:16;;;;;;-1:-1:-1;;;;;41402:16:0;41828:31;43985:58;;;;-1:-1:-1;;;43985:58:0;;11087:2:1;43985:58:0;;;11069:21:1;11126:2;11106:18;;;11099:30;11165;11145:18;;;11138:58;11213:18;;43985:58:0;10885:352:1;43985:58:0;-1:-1:-1;;;;;44392:13:0;;;;;;:9;:13;;;;;;;;:18;;44409:1;44392:18;;;44434:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;44434:21:0;;;;;44473:33;44442:7;;44392:13;;44473:33;;44392:13;;44473:33;38560:155;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:247:1;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;181:9;168:23;200:31;225:5;200:31;:::i;:::-;250:5;14:247;-1:-1:-1;;;14:247:1:o;266:251::-;336:6;389:2;377:9;368:7;364:23;360:32;357:52;;;405:1;402;395:12;357:52;437:9;431:16;456:31;481:5;456:31;:::i;522:388::-;590:6;598;651:2;639:9;630:7;626:23;622:32;619:52;;;667:1;664;657:12;619:52;706:9;693:23;725:31;750:5;725:31;:::i;:::-;775:5;-1:-1:-1;832:2:1;817:18;;804:32;845:33;804:32;845:33;:::i;:::-;897:7;887:17;;;522:388;;;;;:::o;915:456::-;992:6;1000;1008;1061:2;1049:9;1040:7;1036:23;1032:32;1029:52;;;1077:1;1074;1067:12;1029:52;1116:9;1103:23;1135:31;1160:5;1135:31;:::i;:::-;1185:5;-1:-1:-1;1242:2:1;1227:18;;1214:32;1255:33;1214:32;1255:33;:::i;:::-;915:456;;1307:7;;-1:-1:-1;;;1361:2:1;1346:18;;;;1333:32;;915:456::o;1376:1266::-;1471:6;1479;1487;1495;1548:3;1536:9;1527:7;1523:23;1519:33;1516:53;;;1565:1;1562;1555:12;1516:53;1604:9;1591:23;1623:31;1648:5;1623:31;:::i;:::-;1673:5;-1:-1:-1;1730:2:1;1715:18;;1702:32;1743:33;1702:32;1743:33;:::i;:::-;1795:7;-1:-1:-1;1849:2:1;1834:18;;1821:32;;-1:-1:-1;1904:2:1;1889:18;;1876:32;1927:18;1957:14;;;1954:34;;;1984:1;1981;1974:12;1954:34;2022:6;2011:9;2007:22;1997:32;;2067:7;2060:4;2056:2;2052:13;2048:27;2038:55;;2089:1;2086;2079:12;2038:55;2125:2;2112:16;2147:2;2143;2140:10;2137:36;;;2153:18;;:::i;:::-;2228:2;2222:9;2196:2;2282:13;;-1:-1:-1;;2278:22:1;;;2302:2;2274:31;2270:40;2258:53;;;2326:18;;;2346:22;;;2323:46;2320:72;;;2372:18;;:::i;:::-;2412:10;2408:2;2401:22;2447:2;2439:6;2432:18;2487:7;2482:2;2477;2473;2469:11;2465:20;2462:33;2459:53;;;2508:1;2505;2498:12;2459:53;2564:2;2559;2555;2551:11;2546:2;2538:6;2534:15;2521:46;2609:1;2604:2;2599;2591:6;2587:15;2583:24;2576:35;2630:6;2620:16;;;;;;;1376:1266;;;;;;;:::o;2647:416::-;2712:6;2720;2773:2;2761:9;2752:7;2748:23;2744:32;2741:52;;;2789:1;2786;2779:12;2741:52;2828:9;2815:23;2847:31;2872:5;2847:31;:::i;:::-;2897:5;-1:-1:-1;2954:2:1;2939:18;;2926:32;2996:15;;2989:23;2977:36;;2967:64;;3027:1;3024;3017:12;3068:315;3136:6;3144;3197:2;3185:9;3176:7;3172:23;3168:32;3165:52;;;3213:1;3210;3203:12;3165:52;3252:9;3239:23;3271:31;3296:5;3271:31;:::i;:::-;3321:5;3373:2;3358:18;;;;3345:32;;-1:-1:-1;;;3068:315:1:o;3388:615::-;3474:6;3482;3535:2;3523:9;3514:7;3510:23;3506:32;3503:52;;;3551:1;3548;3541:12;3503:52;3591:9;3578:23;3620:18;3661:2;3653:6;3650:14;3647:34;;;3677:1;3674;3667:12;3647:34;3715:6;3704:9;3700:22;3690:32;;3760:7;3753:4;3749:2;3745:13;3741:27;3731:55;;3782:1;3779;3772:12;3731:55;3822:2;3809:16;3848:2;3840:6;3837:14;3834:34;;;3864:1;3861;3854:12;3834:34;3917:7;3912:2;3902:6;3899:1;3895:14;3891:2;3887:23;3883:32;3880:45;3877:65;;;3938:1;3935;3928:12;3877:65;3969:2;3961:11;;;;;3991:6;;-1:-1:-1;3388:615:1;;-1:-1:-1;;;;3388:615:1:o;4008:245::-;4066:6;4119:2;4107:9;4098:7;4094:23;4090:32;4087:52;;;4135:1;4132;4125:12;4087:52;4174:9;4161:23;4193:30;4217:5;4193:30;:::i;4258:249::-;4327:6;4380:2;4368:9;4359:7;4355:23;4351:32;4348:52;;;4396:1;4393;4386:12;4348:52;4428:9;4422:16;4447:30;4471:5;4447:30;:::i;4512:592::-;4583:6;4591;4644:2;4632:9;4623:7;4619:23;4615:32;4612:52;;;4660:1;4657;4650:12;4612:52;4700:9;4687:23;4729:18;4770:2;4762:6;4759:14;4756:34;;;4786:1;4783;4776:12;4756:34;4824:6;4813:9;4809:22;4799:32;;4869:7;4862:4;4858:2;4854:13;4850:27;4840:55;;4891:1;4888;4881:12;4840:55;4931:2;4918:16;4957:2;4949:6;4946:14;4943:34;;;4973:1;4970;4963:12;4943:34;5018:7;5013:2;5004:6;5000:2;4996:15;4992:24;4989:37;4986:57;;;5039:1;5036;5029:12;5109:180;5168:6;5221:2;5209:9;5200:7;5196:23;5192:32;5189:52;;;5237:1;5234;5227:12;5189:52;-1:-1:-1;5260:23:1;;5109:180;-1:-1:-1;5109:180:1:o;5294:257::-;5335:3;5373:5;5367:12;5400:6;5395:3;5388:19;5416:63;5472:6;5465:4;5460:3;5456:14;5449:4;5442:5;5438:16;5416:63;:::i;:::-;5533:2;5512:15;-1:-1:-1;;5508:29:1;5499:39;;;;5540:4;5495:50;;5294:257;-1:-1:-1;;5294:257:1:o;5556:185::-;5598:3;5636:5;5630:12;5651:52;5696:6;5691:3;5684:4;5677:5;5673:16;5651:52;:::i;:::-;5719:16;;;;;5556:185;-1:-1:-1;;5556:185:1:o;5864:1301::-;6141:3;6170:1;6203:6;6197:13;6233:3;6255:1;6283:9;6279:2;6275:18;6265:28;;6343:2;6332:9;6328:18;6365;6355:61;;6409:4;6401:6;6397:17;6387:27;;6355:61;6435:2;6483;6475:6;6472:14;6452:18;6449:38;6446:165;;;-1:-1:-1;;;6510:33:1;;6566:4;6563:1;6556:15;6596:4;6517:3;6584:17;6446:165;6627:18;6654:104;;;;6772:1;6767:320;;;;6620:467;;6654:104;-1:-1:-1;;6687:24:1;;6675:37;;6732:16;;;;-1:-1:-1;6654:104:1;;6767:320;15666:1;15659:14;;;15703:4;15690:18;;6862:1;6876:165;6890:6;6887:1;6884:13;6876:165;;;6968:14;;6955:11;;;6948:35;7011:16;;;;6905:10;;6876:165;;;6880:3;;7070:6;7065:3;7061:16;7054:23;;6620:467;;;;;;;7103:56;7128:30;7154:3;7146:6;7128:30;:::i;:::-;-1:-1:-1;;;5806:20:1;;5851:1;5842:11;;5746:113;7103:56;7096:63;5864:1301;-1:-1:-1;;;;;5864:1301:1:o;7758:488::-;-1:-1:-1;;;;;8027:15:1;;;8009:34;;8079:15;;8074:2;8059:18;;8052:43;8126:2;8111:18;;8104:34;;;8174:3;8169:2;8154:18;;8147:31;;;7952:4;;8195:45;;8220:19;;8212:6;8195:45;:::i;:::-;8187:53;7758:488;-1:-1:-1;;;;;;7758:488:1:o;8667:219::-;8816:2;8805:9;8798:21;8779:4;8836:44;8876:2;8865:9;8861:18;8853:6;8836:44;:::i;9239:409::-;9441:2;9423:21;;;9480:2;9460:18;;;9453:30;9519:34;9514:2;9499:18;;9492:62;-1:-1:-1;;;9585:2:1;9570:18;;9563:43;9638:3;9623:19;;9239:409::o;9653:414::-;9855:2;9837:21;;;9894:2;9874:18;;;9867:30;9933:34;9928:2;9913:18;;9906:62;-1:-1:-1;;;9999:2:1;9984:18;;9977:48;10057:3;10042:19;;9653:414::o;10479:401::-;10681:2;10663:21;;;10720:2;10700:18;;;10693:30;10759:34;10754:2;10739:18;;10732:62;-1:-1:-1;;;10825:2:1;10810:18;;10803:35;10870:3;10855:19;;10479:401::o;15719:128::-;15759:3;15790:1;15786:6;15783:1;15780:13;15777:39;;;15796:18;;:::i;:::-;-1:-1:-1;15832:9:1;;15719:128::o;15852:125::-;15892:4;15920:1;15917;15914:8;15911:34;;;15925:18;;:::i;:::-;-1:-1:-1;15962:9:1;;15852:125::o;15982:258::-;16054:1;16064:113;16078:6;16075:1;16072:13;16064:113;;;16154:11;;;16148:18;16135:11;;;16128:39;16100:2;16093:10;16064:113;;;16195:6;16192:1;16189:13;16186:48;;;-1:-1:-1;;16230:1:1;16212:16;;16205:27;15982:258::o;16245:380::-;16324:1;16320:12;;;;16367;;;16388:61;;16442:4;16434:6;16430:17;16420:27;;16388:61;16495:2;16487:6;16484:14;16464:18;16461:38;16458:161;;;16541:10;16536:3;16532:20;16529:1;16522:31;16576:4;16573:1;16566:15;16604:4;16601:1;16594:15;16458:161;;16245:380;;;:::o;16630:135::-;16669:3;-1:-1:-1;;16690:17:1;;16687:43;;;16710:18;;:::i;:::-;-1:-1:-1;16757:1:1;16746:13;;16630:135::o;16770:127::-;16831:10;16826:3;16822:20;16819:1;16812:31;16862:4;16859:1;16852:15;16886:4;16883:1;16876:15;17034:127;17095:10;17090:3;17086:20;17083:1;17076:31;17126:4;17123:1;17116:15;17150:4;17147:1;17140:15;17166:127;17227:10;17222:3;17218:20;17215:1;17208:31;17258:4;17255:1;17248:15;17282:4;17279:1;17272:15;17298:131;-1:-1:-1;;;;;17373:31:1;;17363:42;;17353:70;;17419:1;17416;17409:12;17434:131;-1:-1:-1;;;;;;17508:32:1;;17498:43;;17488:71;;17555:1;17552;17545:12

ipfs://e200135d08f33dd966750631bf62d5f0c95afb4f9a7fbfbcdc4b04a2a86c421a