Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

library Counters    - function current(Counter storage coun ...    - function increment(Counter storage co ...    - function decrement(Counter storage co ...    - function reset(Counter storage counte ... 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)    - function _msgSender()    - function _msgData() 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)  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 _beforeConsecutiveTokenTrans ...    - function _afterConsecutiveTokenTransf ...    - function tokenURI(uint256 tokenId)    - function _setTokenURI(uint256 tokenId ...    - function _burn(uint256 tokenId)  contract SeedNFT is ERC721URIStora ... *    - function mintToken(string memory toek ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-03-13
*/

// SPDX-License-Identifier: MIT
// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Counters.sol


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

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v4.7.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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Strings.sol


// OpenZeppelin Contracts (last updated v4.7.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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol


// OpenZeppelin Contracts (last updated v4.7.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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts (last updated v4.7.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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol


// OpenZeppelin Contracts (last updated v4.7.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);

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

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

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

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

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

    /**
     * @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 (single) token transfer. This includes minting and burning.
     * See {_beforeConsecutiveTokenTransfer}.
     *
     * 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` and `to` are never both zero.
     *
     * 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 Hook that is called after any (single) transfer of tokens. This includes minting and burning.
     * See {_afterConsecutiveTokenTransfer}.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}

    /**
     * @dev Hook that is called before consecutive token transfers.
     * Calling conditions are similar to {_beforeTokenTransfer}.
     *
     * The default implementation include balances updates that extensions such as {ERC721Consecutive} cannot perform
     * directly.
     */
    function _beforeConsecutiveTokenTransfer(
        address from,
        address to,
        uint256, /*first*/
        uint96 size
    ) internal virtual {
        if (from != address(0)) {
            _balances[from] -= size;
        }
        if (to != address(0)) {
            _balances[to] += size;
        }
    }

    /**
     * @dev Hook that is called after consecutive token transfers.
     * Calling conditions are similar to {_afterTokenTransfer}.
     */
    function _afterConsecutiveTokenTransfer(
        address, /*from*/
        address, /*to*/
        uint256, /*first*/
        uint96 /*size*/
    ) internal virtual {}
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/extensions/ERC721URIStorage.sol


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/extensions/ERC721URIStorage.sol)

pragma solidity ^0.8.0;


/**
 * @dev ERC721 token with storage based token URI management.
 */
abstract contract ERC721URIStorage is ERC721 {
    using Strings for uint256;

    // Optional mapping for token URIs
    mapping(uint256 => string) private _tokenURIs;

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

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

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

        return super.tokenURI(tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @dev See {ERC721-_burn}. This override additionally checks to see if a
     * token-specific URI was set for the token, and if so, it deletes the token URI from
     * the storage mapping.
     */
    function _burn(uint256 tokenId) internal virtual override {
        super._burn(tokenId);

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

// File: Seed/SeedNFT_bybit.sol


pragma solidity 0.8.24;



contract SeedNFT is ERC721URIStorage {

    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    constructor() ERC721("Seed.Photo","SEED"){
    }

    function mintToken(string memory toeknURI) public payable returns(uint) {

        _tokenIds.increment();
        uint256 newItemId = _tokenIds.current();
        // passing newItemId
        _mint(msg.sender,newItemId);
        // Set the token URI : id and url
        _setTokenURI(newItemId,toeknURI);
        // mint the token and set it for sale - return id to do so
        return newItemId;
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"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":[{"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":[{"internalType":"string","name":"toeknURI","type":"string"}],"name":"mintToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"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":"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"}]

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

56078:606:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37925:305;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38853:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40365:171;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39883:416;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;41065:335;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56266:413;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41471:185;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;38563:223;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38294:207;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39022:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40608:155;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;41727:322;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54575:624;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40834:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37925:305;38027:4;38079:25;38064:40;;;:11;:40;;;;:105;;;;38136:33;38121:48;;;:11;:48;;;;38064:105;:158;;;;38186:36;38210:11;38186:23;:36::i;:::-;38064:158;38044:178;;37925:305;;;:::o;38853:100::-;38907:13;38940:5;38933:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38853:100;:::o;40365:171::-;40441:7;40461:23;40476:7;40461:14;:23::i;:::-;40504:15;:24;40520:7;40504:24;;;;;;;;;;;;;;;;;;;;;40497:31;;40365:171;;;:::o;39883:416::-;39964:13;39980:23;39995:7;39980:14;:23::i;:::-;39964:39;;40028:5;40022:11;;:2;:11;;;40014:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;40122:5;40106:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;40131:37;40148:5;40155:12;:10;:12::i;:::-;40131:16;:37::i;:::-;40106:62;40084:173;;;;;;;;;;;;:::i;:::-;;;;;;;;;40270:21;40279:2;40283:7;40270:8;:21::i;:::-;39953:346;39883:416;;:::o;41065:335::-;41260:41;41279:12;:10;:12::i;:::-;41293:7;41260:18;:41::i;:::-;41252:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;41364:28;41374:4;41380:2;41384:7;41364:9;:28::i;:::-;41065:335;;;:::o;56266:413::-;56332:4;56351:21;:9;:19;:21::i;:::-;56383:17;56403:19;:9;:17;:19::i;:::-;56383:39;;56463:27;56469:10;56480:9;56463:5;:27::i;:::-;56544:32;56557:9;56567:8;56544:12;:32::i;:::-;56662:9;56655:16;;;56266:413;;;:::o;41471:185::-;41609:39;41626:4;41632:2;41636:7;41609:39;;;;;;;;;;;;:16;:39::i;:::-;41471:185;;;:::o;38563:223::-;38635:7;38655:13;38671:17;38680:7;38671:8;:17::i;:::-;38655:33;;38724:1;38707:19;;:5;:19;;;38699:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;38773:5;38766:12;;;38563:223;;;:::o;38294:207::-;38366:7;38411:1;38394:19;;:5;:19;;;38386:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;38477:9;:16;38487:5;38477:16;;;;;;;;;;;;;;;;38470:23;;38294:207;;;:::o;39022:104::-;39078:13;39111:7;39104:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39022:104;:::o;40608:155::-;40703:52;40722:12;:10;:12::i;:::-;40736:8;40746;40703:18;:52::i;:::-;40608:155;;:::o;41727:322::-;41901:41;41920:12;:10;:12::i;:::-;41934:7;41901:18;:41::i;:::-;41893:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;42003:38;42017:4;42023:2;42027:7;42036:4;42003:13;:38::i;:::-;41727:322;;;;:::o;54575:624::-;54648:13;54674:23;54689:7;54674:14;:23::i;:::-;54710;54736:10;:19;54747:7;54736:19;;;;;;;;;;;54710:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54766:18;54787:10;:8;:10::i;:::-;54766:31;;54895:1;54879:4;54873:18;:23;54869:72;;54920:9;54913:16;;;;;;54869:72;55071:1;55051:9;55045:23;:27;55041:108;;;55120:4;55126:9;55103:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;55089:48;;;;;;55041:108;55168:23;55183:7;55168:14;:23::i;:::-;55161:30;;;;54575:624;;;;:::o;40834:164::-;40931:4;40955:18;:25;40974:5;40955:25;;;;;;;;;;;;;;;:35;40981:8;40955:35;;;;;;;;;;;;;;;;;;;;;;;;;40948:42;;40834:164;;;;:::o;30278:157::-;30363:4;30402:25;30387:40;;;:11;:40;;;;30380:47;;30278:157;;;:::o;50166:135::-;50248:16;50256:7;50248;:16::i;:::-;50240:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;50166:135;:::o;17588:98::-;17641:7;17668:10;17661:17;;17588:98;:::o;49445:174::-;49547:2;49520:15;:24;49536:7;49520:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;49603:7;49599:2;49565:46;;49574:23;49589:7;49574:14;:23::i;:::-;49565:46;;;;;;;;;;;;49445:174;;:::o;44082:264::-;44175:4;44192:13;44208:23;44223:7;44208:14;:23::i;:::-;44192:39;;44261:5;44250:16;;:7;:16;;;:52;;;;44270:32;44287:5;44294:7;44270:16;:32::i;:::-;44250:52;:87;;;;44330:7;44306:31;;:20;44318:7;44306:11;:20::i;:::-;:31;;;44250:87;44242:96;;;44082:264;;;;:::o;48069:1257::-;48228:4;48201:31;;:23;48216:7;48201:14;:23::i;:::-;:31;;;48193:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;48307:1;48293:16;;:2;:16;;;48285:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;48363:39;48384:4;48390:2;48394:7;48363:20;:39::i;:::-;48532:4;48505:31;;:23;48520:7;48505:14;:23::i;:::-;:31;;;48497:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;48650:15;:24;48666:7;48650:24;;;;;;;;;;;;48643:31;;;;;;;;;;;49145:1;49126:9;:15;49136:4;49126:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;49178:1;49161:9;:13;49171:2;49161:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;49220:2;49201:7;:16;49209:7;49201:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;49259:7;49255:2;49240:27;;49249:4;49240:27;;;;;;;;;;;;49280:38;49300:4;49306:2;49310:7;49280:19;:38::i;:::-;48069:1257;;;:::o;1080:127::-;1187:1;1169:7;:14;;;:19;;;;;;;;;;;1080:127;:::o;958:114::-;1023:7;1050;:14;;;1043:21;;958:114;;;:::o;45680:936::-;45774:1;45760:16;;:2;:16;;;45752:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;45833:16;45841:7;45833;:16::i;:::-;45832:17;45824:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;45895:45;45924:1;45928:2;45932:7;45895:20;:45::i;:::-;46039:16;46047:7;46039;:16::i;:::-;46038:17;46030:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;46454:1;46437:9;:13;46447:2;46437:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;46498:2;46479:7;:16;46487:7;46479:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;46543:7;46539:2;46518:33;;46535:1;46518:33;;;;;;;;;;;;46564:44;46592:1;46596:2;46600:7;46564:19;:44::i;:::-;45680:936;;:::o;55355:217::-;55455:16;55463:7;55455;:16::i;:::-;55447:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;55555:9;55533:10;:19;55544:7;55533:19;;;;;;;;;;;:31;;;;;;:::i;:::-;;55355:217;;:::o;43357:117::-;43423:7;43450;:16;43458:7;43450:16;;;;;;;;;;;;;;;;;;;;;43443:23;;43357:117;;;:::o;49762:315::-;49917:8;49908:17;;:5;:17;;;49900:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;50004:8;49966:18;:25;49985:5;49966:25;;;;;;;;;;;;;;;:35;49992:8;49966:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;50050:8;50028:41;;50043:5;50028:41;;;50060:8;50028:41;;;;;;:::i;:::-;;;;;;;;49762:315;;;:::o;42930:313::-;43086:28;43096:4;43102:2;43106:7;43086:9;:28::i;:::-;43133:47;43156:4;43162:2;43166:7;43175:4;43133:22;:47::i;:::-;43125:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;42930:313;;;;:::o;39727:94::-;39778:13;39804:9;;;;;;;;;;;;;;39727:94;:::o;39197:281::-;39270:13;39296:23;39311:7;39296:14;:23::i;:::-;39332:21;39356:10;:8;:10::i;:::-;39332:34;;39408:1;39390:7;39384:21;:25;:86;;;;;;;;;;;;;;;;;39436:7;39445:18;:7;:16;:18::i;:::-;39419:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;39384:86;39377:93;;;39197:281;;;:::o;43787:128::-;43852:4;43905:1;43876:31;;:17;43885:7;43876:8;:17::i;:::-;:31;;;;43869:38;;43787:128;;;:::o;52338:126::-;;;;:::o;52896:125::-;;;;:::o;50865:853::-;51019:4;51040:15;:2;:13;;;:15::i;:::-;51036:675;;;51092:2;51076:36;;;51113:12;:10;:12::i;:::-;51127:4;51133:7;51142:4;51076:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;51072:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51334:1;51317:6;:13;:18;51313:328;;51360:60;;;;;;;;;;:::i;:::-;;;;;;;;51313:328;51591:6;51585:13;51576:6;51572:2;51568:15;51561:38;51072:584;51208:41;;;51198:51;;;:6;:51;;;;51191:58;;;;;51036:675;51695:4;51688:11;;50865:853;;;;;;;:::o;14962:716::-;15018:13;15069:14;15106:1;15086:17;15097:5;15086:10;:17::i;:::-;:21;15069:38;;15122:20;15156:6;15145:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15122:41;;15178:11;15307:6;15303:2;15299:15;15291:6;15287:28;15280:35;;15344:288;15351:4;15344:288;;;15376:5;;;;;;;;15518:8;15513:2;15506:5;15502:14;15497:30;15492:3;15484:44;15574:2;15565:11;;;;;;:::i;:::-;;;;;15608:1;15599:5;:10;15344:288;15595:21;15344:288;15653:6;15646:13;;;;;14962:716;;;:::o;19088:326::-;19148:4;19405:1;19383:7;:19;;;:23;19376:30;;19088:326;;;:::o;11775:922::-;11828:7;11848:14;11865:1;11848:18;;11915:6;11906:5;:15;11902:102;;11951:6;11942:15;;;;;;:::i;:::-;;;;;11986:2;11976:12;;;;11902:102;12031:6;12022:5;:15;12018:102;;12067:6;12058:15;;;;;;:::i;:::-;;;;;12102:2;12092:12;;;;12018:102;12147:6;12138:5;:15;12134:102;;12183:6;12174:15;;;;;;:::i;:::-;;;;;12218:2;12208:12;;;;12134:102;12263:5;12254;:14;12250:99;;12298:5;12289:14;;;;;;:::i;:::-;;;;;12332:1;12322:11;;;;12250:99;12376:5;12367;:14;12363:99;;12411:5;12402:14;;;;;;:::i;:::-;;;;;12445:1;12435:11;;;;12363:99;12489:5;12480;:14;12476:99;;12524:5;12515:14;;;;;;:::i;:::-;;;;;12558:1;12548:11;;;;12476:99;12602:5;12593;:14;12589:66;;12638:1;12628:11;;;;12589:66;12683:6;12676:13;;;11775:922;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:246::-;1879:1;1889:113;1903:6;1900:1;1897:13;1889:113;;;1988:1;1983:3;1979:11;1973:18;1969:1;1964:3;1960:11;1953:39;1925:2;1922:1;1918:10;1913:15;;1889:113;;;2036:1;2027:6;2022:3;2018:16;2011:27;1860:184;1798:246;;;:::o;2050:102::-;2091:6;2142:2;2138:7;2133:2;2126:5;2122:14;2118:28;2108:38;;2050:102;;;:::o;2158:377::-;2246:3;2274:39;2307:5;2274:39;:::i;:::-;2329:71;2393:6;2388:3;2329:71;:::i;:::-;2322:78;;2409:65;2467:6;2462:3;2455:4;2448:5;2444:16;2409:65;:::i;:::-;2499:29;2521:6;2499:29;:::i;:::-;2494:3;2490:39;2483:46;;2250:285;2158:377;;;;:::o;2541:313::-;2654:4;2692:2;2681:9;2677:18;2669:26;;2741:9;2735:4;2731:20;2727:1;2716:9;2712:17;2705:47;2769:78;2842:4;2833:6;2769:78;:::i;:::-;2761:86;;2541:313;;;;:::o;2860:77::-;2897:7;2926:5;2915:16;;2860:77;;;:::o;2943:122::-;3016:24;3034:5;3016:24;:::i;:::-;3009:5;3006:35;2996:63;;3055:1;3052;3045:12;2996:63;2943:122;:::o;3071:139::-;3117:5;3155:6;3142:20;3133:29;;3171:33;3198:5;3171:33;:::i;:::-;3071:139;;;;:::o;3216:329::-;3275:6;3324:2;3312:9;3303:7;3299:23;3295:32;3292:119;;;3330:79;;:::i;:::-;3292:119;3450:1;3475:53;3520:7;3511:6;3500:9;3496:22;3475:53;:::i;:::-;3465:63;;3421:117;3216:329;;;;:::o;3551:126::-;3588:7;3628:42;3621:5;3617:54;3606:65;;3551:126;;;:::o;3683:96::-;3720:7;3749:24;3767:5;3749:24;:::i;:::-;3738:35;;3683:96;;;:::o;3785:118::-;3872:24;3890:5;3872:24;:::i;:::-;3867:3;3860:37;3785:118;;:::o;3909:222::-;4002:4;4040:2;4029:9;4025:18;4017:26;;4053:71;4121:1;4110:9;4106:17;4097:6;4053:71;:::i;:::-;3909:222;;;;:::o;4137:122::-;4210:24;4228:5;4210:24;:::i;:::-;4203:5;4200:35;4190:63;;4249:1;4246;4239:12;4190:63;4137:122;:::o;4265:139::-;4311:5;4349:6;4336:20;4327:29;;4365:33;4392:5;4365:33;:::i;:::-;4265:139;;;;:::o;4410:474::-;4478:6;4486;4535:2;4523:9;4514:7;4510:23;4506:32;4503:119;;;4541:79;;:::i;:::-;4503:119;4661:1;4686:53;4731:7;4722:6;4711:9;4707:22;4686:53;:::i;:::-;4676:63;;4632:117;4788:2;4814:53;4859:7;4850:6;4839:9;4835:22;4814:53;:::i;:::-;4804:63;;4759:118;4410:474;;;;;:::o;4890:619::-;4967:6;4975;4983;5032:2;5020:9;5011:7;5007:23;5003:32;5000:119;;;5038:79;;:::i;:::-;5000:119;5158:1;5183:53;5228:7;5219:6;5208:9;5204:22;5183:53;:::i;:::-;5173:63;;5129:117;5285:2;5311:53;5356:7;5347:6;5336:9;5332:22;5311:53;:::i;:::-;5301:63;;5256:118;5413:2;5439:53;5484:7;5475:6;5464:9;5460:22;5439:53;:::i;:::-;5429:63;;5384:118;4890:619;;;;;:::o;5515:117::-;5624:1;5621;5614:12;5638:117;5747:1;5744;5737:12;5761:180;5809:77;5806:1;5799:88;5906:4;5903:1;5896:15;5930:4;5927:1;5920:15;5947:281;6030:27;6052:4;6030:27;:::i;:::-;6022:6;6018:40;6160:6;6148:10;6145:22;6124:18;6112:10;6109:34;6106:62;6103:88;;;6171:18;;:::i;:::-;6103:88;6211:10;6207:2;6200:22;5990:238;5947:281;;:::o;6234:129::-;6268:6;6295:20;;:::i;:::-;6285:30;;6324:33;6352:4;6344:6;6324:33;:::i;:::-;6234:129;;;:::o;6369:308::-;6431:4;6521:18;6513:6;6510:30;6507:56;;;6543:18;;:::i;:::-;6507:56;6581:29;6603:6;6581:29;:::i;:::-;6573:37;;6665:4;6659;6655:15;6647:23;;6369:308;;;:::o;6683:146::-;6780:6;6775:3;6770;6757:30;6821:1;6812:6;6807:3;6803:16;6796:27;6683:146;;;:::o;6835:425::-;6913:5;6938:66;6954:49;6996:6;6954:49;:::i;:::-;6938:66;:::i;:::-;6929:75;;7027:6;7020:5;7013:21;7065:4;7058:5;7054:16;7103:3;7094:6;7089:3;7085:16;7082:25;7079:112;;;7110:79;;:::i;:::-;7079:112;7200:54;7247:6;7242:3;7237;7200:54;:::i;:::-;6919:341;6835:425;;;;;:::o;7280:340::-;7336:5;7385:3;7378:4;7370:6;7366:17;7362:27;7352:122;;7393:79;;:::i;:::-;7352:122;7510:6;7497:20;7535:79;7610:3;7602:6;7595:4;7587:6;7583:17;7535:79;:::i;:::-;7526:88;;7342:278;7280:340;;;;:::o;7626:509::-;7695:6;7744:2;7732:9;7723:7;7719:23;7715:32;7712:119;;;7750:79;;:::i;:::-;7712:119;7898:1;7887:9;7883:17;7870:31;7928:18;7920:6;7917:30;7914:117;;;7950:79;;:::i;:::-;7914:117;8055:63;8110:7;8101:6;8090:9;8086:22;8055:63;:::i;:::-;8045:73;;7841:287;7626:509;;;;:::o;8141:118::-;8228:24;8246:5;8228:24;:::i;:::-;8223:3;8216:37;8141:118;;:::o;8265:222::-;8358:4;8396:2;8385:9;8381:18;8373:26;;8409:71;8477:1;8466:9;8462:17;8453:6;8409:71;:::i;:::-;8265:222;;;;:::o;8493:329::-;8552:6;8601:2;8589:9;8580:7;8576:23;8572:32;8569:119;;;8607:79;;:::i;:::-;8569:119;8727:1;8752:53;8797:7;8788:6;8777:9;8773:22;8752:53;:::i;:::-;8742:63;;8698:117;8493:329;;;;:::o;8828:116::-;8898:21;8913:5;8898:21;:::i;:::-;8891:5;8888:32;8878:60;;8934:1;8931;8924:12;8878:60;8828:116;:::o;8950:133::-;8993:5;9031:6;9018:20;9009:29;;9047:30;9071:5;9047:30;:::i;:::-;8950:133;;;;:::o;9089:468::-;9154:6;9162;9211:2;9199:9;9190:7;9186:23;9182:32;9179:119;;;9217:79;;:::i;:::-;9179:119;9337:1;9362:53;9407:7;9398:6;9387:9;9383:22;9362:53;:::i;:::-;9352:63;;9308:117;9464:2;9490:50;9532:7;9523:6;9512:9;9508:22;9490:50;:::i;:::-;9480:60;;9435:115;9089:468;;;;;:::o;9563:307::-;9624:4;9714:18;9706:6;9703:30;9700:56;;;9736:18;;:::i;:::-;9700:56;9774:29;9796:6;9774:29;:::i;:::-;9766:37;;9858:4;9852;9848:15;9840:23;;9563:307;;;:::o;9876:423::-;9953:5;9978:65;9994:48;10035:6;9994:48;:::i;:::-;9978:65;:::i;:::-;9969:74;;10066:6;10059:5;10052:21;10104:4;10097:5;10093:16;10142:3;10133:6;10128:3;10124:16;10121:25;10118:112;;;10149:79;;:::i;:::-;10118:112;10239:54;10286:6;10281:3;10276;10239:54;:::i;:::-;9959:340;9876:423;;;;;:::o;10318:338::-;10373:5;10422:3;10415:4;10407:6;10403:17;10399:27;10389:122;;10430:79;;:::i;:::-;10389:122;10547:6;10534:20;10572:78;10646:3;10638:6;10631:4;10623:6;10619:17;10572:78;:::i;:::-;10563:87;;10379:277;10318:338;;;;:::o;10662:943::-;10757:6;10765;10773;10781;10830:3;10818:9;10809:7;10805:23;10801:33;10798:120;;;10837:79;;:::i;:::-;10798:120;10957:1;10982:53;11027:7;11018:6;11007:9;11003:22;10982:53;:::i;:::-;10972:63;;10928:117;11084:2;11110:53;11155:7;11146:6;11135:9;11131:22;11110:53;:::i;:::-;11100:63;;11055:118;11212:2;11238:53;11283:7;11274:6;11263:9;11259:22;11238:53;:::i;:::-;11228:63;;11183:118;11368:2;11357:9;11353:18;11340:32;11399:18;11391:6;11388:30;11385:117;;;11421:79;;:::i;:::-;11385:117;11526:62;11580:7;11571:6;11560:9;11556:22;11526:62;:::i;:::-;11516:72;;11311:287;10662:943;;;;;;;:::o;11611:474::-;11679:6;11687;11736:2;11724:9;11715:7;11711:23;11707:32;11704:119;;;11742:79;;:::i;:::-;11704:119;11862:1;11887:53;11932:7;11923:6;11912:9;11908:22;11887:53;:::i;:::-;11877:63;;11833:117;11989:2;12015:53;12060:7;12051:6;12040:9;12036:22;12015:53;:::i;:::-;12005:63;;11960:118;11611:474;;;;;:::o;12091:180::-;12139:77;12136:1;12129:88;12236:4;12233:1;12226:15;12260:4;12257:1;12250:15;12277:320;12321:6;12358:1;12352:4;12348:12;12338:22;;12405:1;12399:4;12395:12;12426:18;12416:81;;12482:4;12474:6;12470:17;12460:27;;12416:81;12544:2;12536:6;12533:14;12513:18;12510:38;12507:84;;12563:18;;:::i;:::-;12507:84;12328:269;12277:320;;;:::o;12603:220::-;12743:34;12739:1;12731:6;12727:14;12720:58;12812:3;12807:2;12799:6;12795:15;12788:28;12603:220;:::o;12829:366::-;12971:3;12992:67;13056:2;13051:3;12992:67;:::i;:::-;12985:74;;13068:93;13157:3;13068:93;:::i;:::-;13186:2;13181:3;13177:12;13170:19;;12829:366;;;:::o;13201:419::-;13367:4;13405:2;13394:9;13390:18;13382:26;;13454:9;13448:4;13444:20;13440:1;13429:9;13425:17;13418:47;13482:131;13608:4;13482:131;:::i;:::-;13474:139;;13201:419;;;:::o;13626:248::-;13766:34;13762:1;13754:6;13750:14;13743:58;13835:31;13830:2;13822:6;13818:15;13811:56;13626:248;:::o;13880:366::-;14022:3;14043:67;14107:2;14102:3;14043:67;:::i;:::-;14036:74;;14119:93;14208:3;14119:93;:::i;:::-;14237:2;14232:3;14228:12;14221:19;;13880:366;;;:::o;14252:419::-;14418:4;14456:2;14445:9;14441:18;14433:26;;14505:9;14499:4;14495:20;14491:1;14480:9;14476:17;14469:47;14533:131;14659:4;14533:131;:::i;:::-;14525:139;;14252:419;;;:::o;14677:232::-;14817:34;14813:1;14805:6;14801:14;14794:58;14886:15;14881:2;14873:6;14869:15;14862:40;14677:232;:::o;14915:366::-;15057:3;15078:67;15142:2;15137:3;15078:67;:::i;:::-;15071:74;;15154:93;15243:3;15154:93;:::i;:::-;15272:2;15267:3;15263:12;15256:19;;14915:366;;;:::o;15287:419::-;15453:4;15491:2;15480:9;15476:18;15468:26;;15540:9;15534:4;15530:20;15526:1;15515:9;15511:17;15504:47;15568:131;15694:4;15568:131;:::i;:::-;15560:139;;15287:419;;;:::o;15712:174::-;15852:26;15848:1;15840:6;15836:14;15829:50;15712:174;:::o;15892:366::-;16034:3;16055:67;16119:2;16114:3;16055:67;:::i;:::-;16048:74;;16131:93;16220:3;16131:93;:::i;:::-;16249:2;16244:3;16240:12;16233:19;;15892:366;;;:::o;16264:419::-;16430:4;16468:2;16457:9;16453:18;16445:26;;16517:9;16511:4;16507:20;16503:1;16492:9;16488:17;16481:47;16545:131;16671:4;16545:131;:::i;:::-;16537:139;;16264:419;;;:::o;16689:228::-;16829:34;16825:1;16817:6;16813:14;16806:58;16898:11;16893:2;16885:6;16881:15;16874:36;16689:228;:::o;16923:366::-;17065:3;17086:67;17150:2;17145:3;17086:67;:::i;:::-;17079:74;;17162:93;17251:3;17162:93;:::i;:::-;17280:2;17275:3;17271:12;17264:19;;16923:366;;;:::o;17295:419::-;17461:4;17499:2;17488:9;17484:18;17476:26;;17548:9;17542:4;17538:20;17534:1;17523:9;17519:17;17512:47;17576:131;17702:4;17576:131;:::i;:::-;17568:139;;17295:419;;;:::o;17720:148::-;17822:11;17859:3;17844:18;;17720:148;;;;:::o;17874:390::-;17980:3;18008:39;18041:5;18008:39;:::i;:::-;18063:89;18145:6;18140:3;18063:89;:::i;:::-;18056:96;;18161:65;18219:6;18214:3;18207:4;18200:5;18196:16;18161:65;:::i;:::-;18251:6;18246:3;18242:16;18235:23;;17984:280;17874:390;;;;:::o;18270:435::-;18450:3;18472:95;18563:3;18554:6;18472:95;:::i;:::-;18465:102;;18584:95;18675:3;18666:6;18584:95;:::i;:::-;18577:102;;18696:3;18689:10;;18270:435;;;;;:::o;18711:224::-;18851:34;18847:1;18839:6;18835:14;18828:58;18920:7;18915:2;18907:6;18903:15;18896:32;18711:224;:::o;18941:366::-;19083:3;19104:67;19168:2;19163:3;19104:67;:::i;:::-;19097:74;;19180:93;19269:3;19180:93;:::i;:::-;19298:2;19293:3;19289:12;19282:19;;18941:366;;;:::o;19313:419::-;19479:4;19517:2;19506:9;19502:18;19494:26;;19566:9;19560:4;19556:20;19552:1;19541:9;19537:17;19530:47;19594:131;19720:4;19594:131;:::i;:::-;19586:139;;19313:419;;;:::o;19738:223::-;19878:34;19874:1;19866:6;19862:14;19855:58;19947:6;19942:2;19934:6;19930:15;19923:31;19738:223;:::o;19967:366::-;20109:3;20130:67;20194:2;20189:3;20130:67;:::i;:::-;20123:74;;20206:93;20295:3;20206:93;:::i;:::-;20324:2;20319:3;20315:12;20308:19;;19967:366;;;:::o;20339:419::-;20505:4;20543:2;20532:9;20528:18;20520:26;;20592:9;20586:4;20582:20;20578:1;20567:9;20563:17;20556:47;20620:131;20746:4;20620:131;:::i;:::-;20612:139;;20339:419;;;:::o;20764:182::-;20904:34;20900:1;20892:6;20888:14;20881:58;20764:182;:::o;20952:366::-;21094:3;21115:67;21179:2;21174:3;21115:67;:::i;:::-;21108:74;;21191:93;21280:3;21191:93;:::i;:::-;21309:2;21304:3;21300:12;21293:19;;20952:366;;;:::o;21324:419::-;21490:4;21528:2;21517:9;21513:18;21505:26;;21577:9;21571:4;21567:20;21563:1;21552:9;21548:17;21541:47;21605:131;21731:4;21605:131;:::i;:::-;21597:139;;21324:419;;;:::o;21749:178::-;21889:30;21885:1;21877:6;21873:14;21866:54;21749:178;:::o;21933:366::-;22075:3;22096:67;22160:2;22155:3;22096:67;:::i;:::-;22089:74;;22172:93;22261:3;22172:93;:::i;:::-;22290:2;22285:3;22281:12;22274:19;;21933:366;;;:::o;22305:419::-;22471:4;22509:2;22498:9;22494:18;22486:26;;22558:9;22552:4;22548:20;22544:1;22533:9;22529:17;22522:47;22586:131;22712:4;22586:131;:::i;:::-;22578:139;;22305:419;;;:::o;22730:233::-;22870:34;22866:1;22858:6;22854:14;22847:58;22939:16;22934:2;22926:6;22922:15;22915:41;22730:233;:::o;22969:366::-;23111:3;23132:67;23196:2;23191:3;23132:67;:::i;:::-;23125:74;;23208:93;23297:3;23208:93;:::i;:::-;23326:2;23321:3;23317:12;23310:19;;22969:366;;;:::o;23341:419::-;23507:4;23545:2;23534:9;23530:18;23522:26;;23594:9;23588:4;23584:20;23580:1;23569:9;23565:17;23558:47;23622:131;23748:4;23622:131;:::i;:::-;23614:139;;23341:419;;;:::o;23766:141::-;23815:4;23838:3;23830:11;;23861:3;23858:1;23851:14;23895:4;23892:1;23882:18;23874:26;;23766:141;;;:::o;23913:93::-;23950:6;23997:2;23992;23985:5;23981:14;23977:23;23967:33;;23913:93;;;:::o;24012:107::-;24056:8;24106:5;24100:4;24096:16;24075:37;;24012:107;;;;:::o;24125:393::-;24194:6;24244:1;24232:10;24228:18;24267:97;24297:66;24286:9;24267:97;:::i;:::-;24385:39;24415:8;24404:9;24385:39;:::i;:::-;24373:51;;24457:4;24453:9;24446:5;24442:21;24433:30;;24506:4;24496:8;24492:19;24485:5;24482:30;24472:40;;24201:317;;24125:393;;;;;:::o;24524:60::-;24552:3;24573:5;24566:12;;24524:60;;;:::o;24590:142::-;24640:9;24673:53;24691:34;24700:24;24718:5;24700:24;:::i;:::-;24691:34;:::i;:::-;24673:53;:::i;:::-;24660:66;;24590:142;;;:::o;24738:75::-;24781:3;24802:5;24795:12;;24738:75;;;:::o;24819:269::-;24929:39;24960:7;24929:39;:::i;:::-;24990:91;25039:41;25063:16;25039:41;:::i;:::-;25031:6;25024:4;25018:11;24990:91;:::i;:::-;24984:4;24977:105;24895:193;24819:269;;;:::o;25094:73::-;25139:3;25094:73;:::o;25173:189::-;25250:32;;:::i;:::-;25291:65;25349:6;25341;25335:4;25291:65;:::i;:::-;25226:136;25173:189;;:::o;25368:186::-;25428:120;25445:3;25438:5;25435:14;25428:120;;;25499:39;25536:1;25529:5;25499:39;:::i;:::-;25472:1;25465:5;25461:13;25452:22;;25428:120;;;25368:186;;:::o;25560:543::-;25661:2;25656:3;25653:11;25650:446;;;25695:38;25727:5;25695:38;:::i;:::-;25779:29;25797:10;25779:29;:::i;:::-;25769:8;25765:44;25962:2;25950:10;25947:18;25944:49;;;25983:8;25968:23;;25944:49;26006:80;26062:22;26080:3;26062:22;:::i;:::-;26052:8;26048:37;26035:11;26006:80;:::i;:::-;25665:431;;25650:446;25560:543;;;:::o;26109:117::-;26163:8;26213:5;26207:4;26203:16;26182:37;;26109:117;;;;:::o;26232:169::-;26276:6;26309:51;26357:1;26353:6;26345:5;26342:1;26338:13;26309:51;:::i;:::-;26305:56;26390:4;26384;26380:15;26370:25;;26283:118;26232:169;;;;:::o;26406:295::-;26482:4;26628:29;26653:3;26647:4;26628:29;:::i;:::-;26620:37;;26690:3;26687:1;26683:11;26677:4;26674:21;26666:29;;26406:295;;;;:::o;26706:1395::-;26823:37;26856:3;26823:37;:::i;:::-;26925:18;26917:6;26914:30;26911:56;;;26947:18;;:::i;:::-;26911:56;26991:38;27023:4;27017:11;26991:38;:::i;:::-;27076:67;27136:6;27128;27122:4;27076:67;:::i;:::-;27170:1;27194:4;27181:17;;27226:2;27218:6;27215:14;27243:1;27238:618;;;;27900:1;27917:6;27914:77;;;27966:9;27961:3;27957:19;27951:26;27942:35;;27914:77;28017:67;28077:6;28070:5;28017:67;:::i;:::-;28011:4;28004:81;27873:222;27208:887;;27238:618;27290:4;27286:9;27278:6;27274:22;27324:37;27356:4;27324:37;:::i;:::-;27383:1;27397:208;27411:7;27408:1;27405:14;27397:208;;;27490:9;27485:3;27481:19;27475:26;27467:6;27460:42;27541:1;27533:6;27529:14;27519:24;;27588:2;27577:9;27573:18;27560:31;;27434:4;27431:1;27427:12;27422:17;;27397:208;;;27633:6;27624:7;27621:19;27618:179;;;27691:9;27686:3;27682:19;27676:26;27734:48;27776:4;27768:6;27764:17;27753:9;27734:48;:::i;:::-;27726:6;27719:64;27641:156;27618:179;27843:1;27839;27831:6;27827:14;27823:22;27817:4;27810:36;27245:611;;;27208:887;;26798:1303;;;26706:1395;;:::o;28107:175::-;28247:27;28243:1;28235:6;28231:14;28224:51;28107:175;:::o;28288:366::-;28430:3;28451:67;28515:2;28510:3;28451:67;:::i;:::-;28444:74;;28527:93;28616:3;28527:93;:::i;:::-;28645:2;28640:3;28636:12;28629:19;;28288:366;;;:::o;28660:419::-;28826:4;28864:2;28853:9;28849:18;28841:26;;28913:9;28907:4;28903:20;28899:1;28888:9;28884:17;28877:47;28941:131;29067:4;28941:131;:::i;:::-;28933:139;;28660:419;;;:::o;29085:237::-;29225:34;29221:1;29213:6;29209:14;29202:58;29294:20;29289:2;29281:6;29277:15;29270:45;29085:237;:::o;29328:366::-;29470:3;29491:67;29555:2;29550:3;29491:67;:::i;:::-;29484:74;;29567:93;29656:3;29567:93;:::i;:::-;29685:2;29680:3;29676:12;29669:19;;29328:366;;;:::o;29700:419::-;29866:4;29904:2;29893:9;29889:18;29881:26;;29953:9;29947:4;29943:20;29939:1;29928:9;29924:17;29917:47;29981:131;30107:4;29981:131;:::i;:::-;29973:139;;29700:419;;;:::o;30125:98::-;30176:6;30210:5;30204:12;30194:22;;30125:98;;;:::o;30229:168::-;30312:11;30346:6;30341:3;30334:19;30386:4;30381:3;30377:14;30362:29;;30229:168;;;;:::o;30403:373::-;30489:3;30517:38;30549:5;30517:38;:::i;:::-;30571:70;30634:6;30629:3;30571:70;:::i;:::-;30564:77;;30650:65;30708:6;30703:3;30696:4;30689:5;30685:16;30650:65;:::i;:::-;30740:29;30762:6;30740:29;:::i;:::-;30735:3;30731:39;30724:46;;30493:283;30403:373;;;;:::o;30782:640::-;30977:4;31015:3;31004:9;31000:19;30992:27;;31029:71;31097:1;31086:9;31082:17;31073:6;31029:71;:::i;:::-;31110:72;31178:2;31167:9;31163:18;31154:6;31110:72;:::i;:::-;31192;31260:2;31249:9;31245:18;31236:6;31192:72;:::i;:::-;31311:9;31305:4;31301:20;31296:2;31285:9;31281:18;31274:48;31339:76;31410:4;31401:6;31339:76;:::i;:::-;31331:84;;30782:640;;;;;;;:::o;31428:141::-;31484:5;31515:6;31509:13;31500:22;;31531:32;31557:5;31531:32;:::i;:::-;31428:141;;;;:::o;31575:349::-;31644:6;31693:2;31681:9;31672:7;31668:23;31664:32;31661:119;;;31699:79;;:::i;:::-;31661:119;31819:1;31844:63;31899:7;31890:6;31879:9;31875:22;31844:63;:::i;:::-;31834:73;;31790:127;31575:349;;;;:::o;31930:180::-;31978:77;31975:1;31968:88;32075:4;32072:1;32065:15;32099:4;32096:1;32089:15

ipfs://e0dae93921dd5834299c6dd16348d94c4608e98d0fa3a7864c171abf635e6768