Token Non-Playable Customs: Genesis Edition

/**
 *Submitted for verification at basescan.org on 2024-02-15
*/

/**
 *Submitted for verification at Etherscan.io on 2024-01-31
 */

// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(
        address sender,
        uint256 balance,
        uint256 needed
    );

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(
        address spender,
        uint256 allowance,
        uint256 needed
    );

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(
        address sender,
        uint256 balance,
        uint256 needed,
        uint256 tokenId
    );

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// File: @openzeppelin/contracts/utils/math/SignedMath.sol

// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// File: @openzeppelin/contracts/utils/math/Math.sol

// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

    /**
     * @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 towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (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 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 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.

            uint256 twos = denominator & (0 - denominator);
            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 (unsignedRoundsUp(rounding) && 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
     * towards zero.
     *
     * 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 +
                (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * 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 +
                (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * 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 +
                (unsignedRoundsUp(rounding) && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * 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 256, 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 +
                (
                    unsignedRoundsUp(rounding) && 1 << (result << 3) < value
                        ? 1
                        : 0
                );
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

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

// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)

pragma solidity ^0.8.20;

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

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @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), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value)
        internal
        pure
        returns (string memory)
    {
        return
            string.concat(
                value < 0 ? "-" : "",
                toString(SignedMath.abs(value))
            );
    }

    /**
     * @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)
    {
        uint256 localValue = value;
        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] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        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);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b)
        internal
        pure
        returns (bool)
    {
        return
            bytes(a).length == bytes(b).length &&
            keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

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

// OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @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/access/Ownable.sol

// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @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 {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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);
    }
}

pragma solidity ^0.8.20;

/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. 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 Admin is Context, Ownable {
    address private _admin;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error AdminUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error AdminInvalidOwner(address admin);

    event AdminTransferred(
        address indexed previousAdmin,
        address indexed newAdmin
    );

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialAdmin) {
        if (initialAdmin == address(0)) {
            revert AdminInvalidOwner(address(0));
        }
        _transferAdmin(initialAdmin);
    }

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkAdmin() internal view virtual {
        if (admin() != _msgSender()) {
            revert AdminUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferAdmin(address newAdmin) public virtual onlyOwner {
        if (newAdmin == address(0)) {
            revert AdminInvalidOwner(address(0));
        }
        _transferAdmin(newAdmin);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferAdmin(address newAdmin) internal virtual {
        address oldAdmin = _admin;
        _admin = newAdmin;
        emit AdminTransferred(oldAdmin, newAdmin);
    }
}

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

// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    bool private _paused;

    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    /**
     * @dev The operation failed because the contract is paused.
     */
    error EnforcedPause();

    /**
     * @dev The operation failed because the contract is not paused.
     */
    error ExpectedPause();

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        if (paused()) {
            revert EnforcedPause();
        }
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        if (!paused()) {
            revert ExpectedPause();
        }
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

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

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.20;

/**
 * @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 (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @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/interfaces/IERC165.sol

// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)

pragma solidity ^0.8.20;

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

// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

/**
 * @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);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        returns (bool)
    {
        return interfaceId == type(IERC165).interfaceId;
    }
}

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

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.20;

/**
 * @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 address zero.
     *
     * 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/interfaces/IERC721.sol

// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC721.sol)

pragma solidity ^0.8.20;

// File: @openzeppelin/contracts/interfaces/IERC4906.sol

// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC4906.sol)

pragma solidity ^0.8.20;

/// @title EIP-721 Metadata Update Extension
interface IERC4906 is IERC165, IERC721 {
    /// @dev This event emits when the metadata of a token is changed.
    /// So that the third-party platforms such as NFT market could
    /// timely update the images and related attributes of the NFT.
    event MetadataUpdate(uint256 _tokenId);

    /// @dev This event emits when the metadata of a range of tokens is changed.
    /// So that the third-party platforms such as NFT market could
    /// timely update the images and related attributes of the NFTs.
    event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
}

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

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.20;

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

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

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

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

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.20;

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

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

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

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

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.20;

/**
 * @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}.
 */
abstract contract ERC721 is
    Context,
    ERC165,
    IERC721,
    IERC721Metadata,
    IERC721Errors
{
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    mapping(uint256 => address) private _owners;

    mapping(address => uint256) private _balances;

    mapping(uint256 => address) private _tokenApprovals;

    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 returns (uint256) {
        if (owner == address(0)) {
            revert ERC721InvalidOwner(address(0));
        }
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual returns (address) {
        return _requireOwned(tokenId);
    }

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

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

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

        string memory baseURI = _baseURI();
        return
            bytes(baseURI).length > 0
                ? string.concat(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 {
        _approve(to, tokenId, _msgSender());
    }

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

        return _getApproved(tokenId);
    }

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        address previousOwner = _update(to, tokenId, _msgSender());
        if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) public virtual {
        transferFrom(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     *
     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the
     * core ERC721 logic MUST be matched with the use of {_increaseBalance} to keep balances
     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by
     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.
     */
    function _getApproved(uint256 tokenId)
        internal
        view
        virtual
        returns (address)
    {
        return _tokenApprovals[tokenId];
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in
     * particular (ignoring whether it is owned by `owner`).
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _isAuthorized(
        address owner,
        address spender,
        uint256 tokenId
    ) internal view virtual returns (bool) {
        return
            spender != address(0) &&
            (owner == spender ||
                isApprovedForAll(owner, spender) ||
                _getApproved(tokenId) == spender);
    }

    /**
     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.
     * Reverts if `spender` does not have approval from the provided `owner` for the given token or for all its assets
     * the `spender` for the specific `tokenId`.
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _checkAuthorized(
        address owner,
        address spender,
        uint256 tokenId
    ) internal view virtual {
        if (!_isAuthorized(owner, spender, tokenId)) {
            if (owner == address(0)) {
                revert ERC721NonexistentToken(tokenId);
            } else {
                revert ERC721InsufficientApproval(spender, tokenId);
            }
        }
    }

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that
     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.
     *
     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the
     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership
     * remain consistent with one another.
     */
    function _increaseBalance(address account, uint128 value) internal virtual {
        unchecked {
            _balances[account] += value;
        }
    }

    /**
     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner
     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that
     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).
     *
     * Emits a {Transfer} event.
     *
     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.
     */
    function _update(
        address to,
        uint256 tokenId,
        address auth
    ) internal virtual returns (address) {
        address from = _ownerOf(tokenId);

        // Perform (optional) operator check
        if (auth != address(0)) {
            _checkAuthorized(from, auth, tokenId);
        }

        // Execute the update
        if (from != address(0)) {
            // Clear approval. No need to re-authorize or emit the Approval event
            _approve(address(0), tokenId, address(0), false);

            unchecked {
                _balances[from] -= 1;
            }
        }

        if (to != address(0)) {
            unchecked {
                _balances[to] += 1;
            }
        }

        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        return from;
    }

    /**
     * @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 {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner != address(0)) {
            revert ERC721InvalidSender(address(0));
        }
    }

    /**
     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.
     *
     * 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 {
        _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);
        _checkOnERC721Received(address(0), to, tokenId, data);
    }

    /**
     * @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 {
        address previousOwner = _update(address(0), tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(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 {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        } else if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients
     * are aware of the ERC721 standard 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 like {safeTransferFrom} in the sense that it invokes
     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `tokenId` token must exist and be owned by `from`.
     * - `to` cannot be the zero address.
     * - `from` cannot be the zero address.
     * - 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
    ) internal {
        _safeTransfer(from, to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) internal virtual {
        _transfer(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is
     * either the owner of the token, or approved to operate on all tokens held by this owner.
     *
     * Emits an {Approval} event.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(
        address to,
        uint256 tokenId,
        address auth
    ) internal {
        _approve(to, tokenId, auth, true);
    }

    /**
     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not
     * emitted in the context of transfers.
     */
    function _approve(
        address to,
        uint256 tokenId,
        address auth,
        bool emitEvent
    ) internal virtual {
        // Avoid reading the owner unless necessary
        if (emitEvent || auth != address(0)) {
            address owner = _requireOwned(tokenId);

            // We do not use _isAuthorized because single-token approvals should not be able to call approve
            if (
                auth != address(0) &&
                owner != auth &&
                !isApprovedForAll(owner, auth)
            ) {
                revert ERC721InvalidApprover(auth);
            }

            if (emitEvent) {
                emit Approval(owner, to, tokenId);
            }
        }

        _tokenApprovals[tokenId] = to;
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Requirements:
     * - operator can't be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        if (operator == address(0)) {
            revert ERC721InvalidOperator(operator);
        }
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).
     * Returns the owner.
     *
     * Overrides to ownership logic should be done to {_ownerOf}.
     */
    function _requireOwned(uint256 tokenId) internal view returns (address) {
        address owner = _ownerOf(tokenId);
        if (owner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
        return owner;
    }

    /**
     * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target address. This will revert if the
     * recipient doesn't accept the token transfer. 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
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) private {
        if (to.code.length > 0) {
            try
                IERC721Receiver(to).onERC721Received(
                    _msgSender(),
                    from,
                    tokenId,
                    data
                )
            returns (bytes4 retval) {
                if (retval != IERC721Receiver.onERC721Received.selector) {
                    revert ERC721InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert ERC721InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }
}

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

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/ERC721Burnable.sol)

pragma solidity ^0.8.20;

/**
 * @title ERC721 Burnable Token
 * @dev ERC721 Token that can be burned (destroyed).
 */
abstract contract ERC721Burnable is Context, ERC721 {
    /**
     * @dev Burns `tokenId`. See {ERC721-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual {
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        _update(address(0), tokenId, _msgSender());
    }
}

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

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/ERC721Pausable.sol)

pragma solidity ^0.8.20;

/**
 * @dev ERC721 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 *
 * IMPORTANT: This contract does not include public pause and unpause functions. In
 * addition to inheriting this contract, you must define both functions, invoking the
 * {Pausable-_pause} and {Pausable-_unpause} internal functions, with appropriate
 * access control, e.g. using {AccessControl} or {Ownable}. Not doing so will
 * make the contract pause mechanism of the contract unreachable, and thus unusable.
 */
abstract contract ERC721Pausable is ERC721, Pausable {
    /**
     * @dev See {ERC721-_update}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    function _update(
        address to,
        uint256 tokenId,
        address auth
    ) internal virtual override whenNotPaused returns (address) {
        return super._update(to, tokenId, auth);
    }
}

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

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/ERC721URIStorage.sol)

pragma solidity ^0.8.20;

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

    // Interface ID as defined in ERC-4906. This does not correspond to a traditional interface ID as ERC-4906 only
    // defines events and does not include any external function.
    bytes4 private constant ERC4906_INTERFACE_ID = bytes4(0x49064906);

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        _requireOwned(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 string.concat).
        if (bytes(_tokenURI).length > 0) {
            return string.concat(base, _tokenURI);
        }

        return super.tokenURI(tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Emits {MetadataUpdate}.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI)
        public
        virtual
        onlyAdmin
    {
        _tokenURIs[tokenId] = _tokenURI;
        emit MetadataUpdate(tokenId);
    }
}

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

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/ERC721Enumerable.sol)

pragma solidity ^0.8.20;

/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds enumerability
 * of all the token ids in the contract as well as all token ids owned by each account.
 *
 * CAUTION: `ERC721` extensions that implement custom `balanceOf` logic, such as `ERC721Consecutive`,
 * interfere with enumerability and should not be used together with `ERC721Enumerable`.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
    mapping(uint256 => uint256) private _ownedTokensIndex;

    uint256[] private _allTokens;
    mapping(uint256 => uint256) private _allTokensIndex;

    /**
     * @dev An `owner`'s token query was out of bounds for `index`.
     *
     * NOTE: The owner being `address(0)` indicates a global out of bounds index.
     */
    error ERC721OutOfBoundsIndex(address owner, uint256 index);

    /**
     * @dev Batch mint is not allowed.
     */
    error ERC721EnumerableForbiddenBatchMint();

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index)
        public
        view
        virtual
        returns (uint256)
    {
        if (index >= balanceOf(owner)) {
            revert ERC721OutOfBoundsIndex(owner, index);
        }
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual returns (uint256) {
        if (index >= totalSupply()) {
            revert ERC721OutOfBoundsIndex(address(0), index);
        }
        return _allTokens[index];
    }

    /**
     * @dev See {ERC721-_update}.
     */
    function _update(
        address to,
        uint256 tokenId,
        address auth
    ) internal virtual override returns (address) {
        address previousOwner = super._update(to, tokenId, auth);

        if (previousOwner == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (previousOwner != to) {
            _removeTokenFromOwnerEnumeration(previousOwner, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (previousOwner != to) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }

        return previousOwner;
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = balanceOf(to) - 1;
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId)
        private
    {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = balanceOf(from);
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }

    /**
     * See {ERC721-_increaseBalance}. We need that to account tokens that were minted in batch
     */
    function _increaseBalance(address account, uint128 amount)
        internal
        virtual
        override
    {
        if (amount > 0) {
            revert ERC721EnumerableForbiddenBatchMint();
        }
        super._increaseBalance(account, amount);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

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

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

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

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

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

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

// TraitsStorage.sol
pragma solidity ^0.8.19;

abstract contract TraitsStorage is Ownable {
    uint256 public moodCount;
    uint256 public backgroundCount;
    uint256 public torsoCount;
    uint256 public faceSlot1Count;
    uint256 public faceSlot2Count;
    uint256 public piercingsCount;
    uint256 public eyeWearandGlassesCount;
    uint256 public hairstylesAndHatsCount;
    uint256 public itemsCount;

    constructor() {
        moodCount = 2;
        backgroundCount = 65;
        torsoCount = 34;
        faceSlot1Count = 12;
        faceSlot2Count = 10;
        piercingsCount = 6;
        eyeWearandGlassesCount = 21;
        hairstylesAndHatsCount = 49;
        itemsCount = 29;
    }

    struct TraitIndices {
        uint256 background;
        uint256 mood;
        uint256 torso;
        uint256 faceSlot1;
        uint256 faceSlot2;
        uint256 piercings;
        uint256 eyewearAndGlasses;
        uint256 hairstyleAndHats;
        uint256 item;
    }
    mapping(bytes32 => bool) public mintedCombinations;
    mapping(uint256 => bytes) public tokenTraits;

    function generateCombinationHash(TraitIndices memory indices)
        internal
        pure
        returns (bytes32)
    {
        return
            keccak256(
                abi.encode(
                    indices.background,
                    indices.mood,
                    indices.torso,
                    indices.faceSlot1,
                    indices.faceSlot2,
                    indices.piercings,
                    indices.eyewearAndGlasses,
                    indices.hairstyleAndHats,
                    indices.item
                )
            );
    }

    function generateCombinationForAPI(TraitIndices memory indices)
        internal
        pure
        returns (bytes memory)
    {
        return
            abi.encode(
                indices.background,
                indices.mood,
                indices.torso,
                indices.faceSlot1,
                indices.faceSlot2,
                indices.piercings,
                indices.eyewearAndGlasses,
                indices.hairstyleAndHats,
                indices.item
            );
    }

    function isMinted(TraitIndices memory indices) public view returns (bool) {
        bytes32 combinationHash = generateCombinationHash(indices);
        return mintedCombinations[combinationHash];
    }

    function tokenTraitsById(uint256 tokenID)
        public
        view
        returns (TraitIndices memory)
    {
        return abi.decode(tokenTraits[tokenID], (TraitIndices));
    }

    function _validateAndSetCombinationHash(
        bytes32 combinationHash,
        TraitIndices memory combinationOfTraits,
        uint256 tokenId
    ) internal {
        require(!mintedCombinations[combinationHash], "Minted combination.");
        mintedCombinations[combinationHash] = true;
        tokenTraits[tokenId] = generateCombinationForAPI(combinationOfTraits);
    }

    function addBackground(bool action) external onlyOwner returns (uint256) {
        if (action) {
            backgroundCount = backgroundCount + 1;
        } else {
            require(backgroundCount > 0, "cannot be negative");
            backgroundCount = backgroundCount - 1;
        }
        return backgroundCount;
    }

    function addTorso(bool action) external onlyOwner returns (uint256) {
        if (action) {
            torsoCount = torsoCount + 1;
        } else {
            require(torsoCount > 0, "cannot be negative");
            torsoCount = torsoCount - 1;
        }
        return torsoCount;
    }

    function addFaceSlot1(bool action) external onlyOwner returns (uint256) {
        if (action) {
            faceSlot1Count = faceSlot1Count + 1;
        } else {
            require(faceSlot1Count > 0, "cannot be negative");
            faceSlot1Count = faceSlot1Count - 1;
        }
        return faceSlot1Count;
    }

    function addFaceSlot2(bool action) external onlyOwner returns (uint256) {
        if (action) {
            faceSlot2Count = faceSlot2Count + 1;
        } else {
            require(faceSlot2Count > 0, "cannot be negative");
            faceSlot2Count = faceSlot2Count - 1;
        }
        return faceSlot2Count;
    }

    function addPiercings(bool action) external onlyOwner returns (uint256) {
        if (action) {
            piercingsCount = piercingsCount + 1;
        } else {
            require(piercingsCount > 0, "cannot be negative");
            piercingsCount = piercingsCount - 1;
        }
        return piercingsCount;
    }

    function addEyewearAndGlasses(bool action)
        external
        onlyOwner
        returns (uint256)
    {
        if (action) {
            eyeWearandGlassesCount = eyeWearandGlassesCount + 1;
        } else {
            require(eyeWearandGlassesCount > 0, "cannot be negative");
            eyeWearandGlassesCount = eyeWearandGlassesCount - 1;
        }
        return eyeWearandGlassesCount;
    }

    function addHairstyleAndHats(bool action)
        external
        onlyOwner
        returns (uint256)
    {
        if (action) {
            hairstylesAndHatsCount = hairstylesAndHatsCount + 1;
        } else {
            require(hairstylesAndHatsCount > 0, "cannot be negative");
            hairstylesAndHatsCount = hairstylesAndHatsCount - 1;
        }
        return hairstylesAndHatsCount;
    }

    function addItem(bool action) external onlyOwner returns (uint256) {
        if (action) {
            itemsCount = itemsCount + 1;
        } else {
            require(itemsCount > 0, "cannot be negative");
            itemsCount = itemsCount - 1;
        }
        return itemsCount;
    }
}

pragma solidity ^0.8.20;

contract NonPlayableCustoms is
    ERC721,
    ERC721Enumerable,
    Ownable,
    Admin,
    ERC721URIStorage,
    ERC721Pausable,
    ERC721Burnable,
    TraitsStorage,
    ReentrancyGuard
{
    uint256 private _pricePerMint;
    uint256 private _nextTokenId;
    address private _erc20TokenAddress;
    uint256 public _maxSupply;
    uint256 public mintingFee;

    address public tokenUriSetter;

    event MintedToken(uint256 _tokenId);

    constructor(address erc20TokenAddress_, address tokenUriSetter_)
        // uint256 pricePerMint_,
        // uint256 maxSupply_
        ERC721("Non-Playable Customs: Genesis Edition", "NPCustom")
        Ownable(msg.sender)
        Admin(tokenUriSetter_)
    {
        _erc20TokenAddress = erc20TokenAddress_;
        _pricePerMint = 1000000000000000000;
        _maxSupply = 155443;
        mintingFee = 0.000088 ether;
        tokenUriSetter = tokenUriSetter_;
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

    function mint(address to, TraitIndices memory indices)
        public
        payable
        nonReentrant
    {
        require(
            msg.value == mintingFee,
            "Sent value must be equal to minting fee"
        );
        require(indices.background < backgroundCount, "Invalid");
        require(indices.mood < moodCount, "Invalid");
        require(indices.torso < torsoCount, "Invalid");
        require(indices.faceSlot1 < faceSlot1Count, "Invalid");
        require(indices.faceSlot2 < faceSlot2Count, "Invalid");
        require(indices.piercings < piercingsCount, "Invalid");
        require(indices.eyewearAndGlasses < eyeWearandGlassesCount, "Invalid");
        require(indices.hairstyleAndHats < hairstylesAndHatsCount, "Invalid");
        require(indices.item < itemsCount, "Invalid");
        if (_nextTokenId + 1 > _maxSupply) revert();
        uint256 tokenId = _nextTokenId++;
        _chargeMints();
        withdrawMintingFee();
        bytes32 combinationHash = generateCombinationHash(indices);
        _validateAndSetCombinationHash(combinationHash, indices, tokenId);
        _safeMint(to, tokenId);
        emit MintedToken(tokenId);
    }

    function _chargeMints() internal {
        IERC20(_erc20TokenAddress).transferFrom(
            msg.sender,
            address(0x000000000000000000000000000000000000dEaD),
            _pricePerMint
        );
    }

    function NPCTokenAddress() public view returns (address) {
        return _erc20TokenAddress;
    }

    function pricePerMint() public view returns (uint256) {
        return _pricePerMint;
    }

    function setMintingFee(uint256 newPrice) external onlyOwner {
        require(newPrice > 0, "Price must be at least 1 wei");
        mintingFee = newPrice;
    }

    function getBalance() public view returns (uint256) {
        return address(this).balance;
    }

    function withdrawMintingFee() internal {
        address payable to = payable(admin());
        to.transfer(getBalance());
    }

    // The following functions are overrides required by Solidity.

    function _update(
        address to,
        uint256 tokenId,
        address auth
    )
        internal
        override(ERC721, ERC721Enumerable, ERC721Pausable)
        returns (address)
    {
        return super._update(to, tokenId, auth);
    }

    function _increaseBalance(address account, uint128 value)
        internal
        override(ERC721, ERC721Enumerable)
    {
        super._increaseBalance(account, value);
    }

    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (string memory)
    {
        return super.tokenURI(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721Enumerable, ERC721URIStorage)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"erc20TokenAddress_","type":"address"},{"internalType":"address","name":"tokenUriSetter_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"admin","type":"address"}],"name":"AdminInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AdminUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ERC721EnumerableForbiddenBatchMint","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721IncorrectOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721InsufficientApproval","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC721InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC721InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721InvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC721InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC721InvalidSender","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721NonexistentToken","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"ERC721OutOfBoundsIndex","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":true,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminTransferred","type":"event"},{"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":false,"internalType":"uint256","name":"_fromTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_toTokenId","type":"uint256"}],"name":"BatchMetadataUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"MetadataUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"MintedToken","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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"NPCTokenAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"string","name":"_tokenURI","type":"string"}],"name":"_setTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"action","type":"bool"}],"name":"addBackground","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"action","type":"bool"}],"name":"addEyewearAndGlasses","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"action","type":"bool"}],"name":"addFaceSlot1","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"action","type":"bool"}],"name":"addFaceSlot2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"action","type":"bool"}],"name":"addHairstyleAndHats","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"action","type":"bool"}],"name":"addItem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"action","type":"bool"}],"name":"addPiercings","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"action","type":"bool"}],"name":"addTorso","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"backgroundCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"eyeWearandGlassesCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"faceSlot1Count","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"faceSlot2Count","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":[],"name":"getBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hairstylesAndHatsCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"background","type":"uint256"},{"internalType":"uint256","name":"mood","type":"uint256"},{"internalType":"uint256","name":"torso","type":"uint256"},{"internalType":"uint256","name":"faceSlot1","type":"uint256"},{"internalType":"uint256","name":"faceSlot2","type":"uint256"},{"internalType":"uint256","name":"piercings","type":"uint256"},{"internalType":"uint256","name":"eyewearAndGlasses","type":"uint256"},{"internalType":"uint256","name":"hairstyleAndHats","type":"uint256"},{"internalType":"uint256","name":"item","type":"uint256"}],"internalType":"struct TraitsStorage.TraitIndices","name":"indices","type":"tuple"}],"name":"isMinted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"itemsCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"components":[{"internalType":"uint256","name":"background","type":"uint256"},{"internalType":"uint256","name":"mood","type":"uint256"},{"internalType":"uint256","name":"torso","type":"uint256"},{"internalType":"uint256","name":"faceSlot1","type":"uint256"},{"internalType":"uint256","name":"faceSlot2","type":"uint256"},{"internalType":"uint256","name":"piercings","type":"uint256"},{"internalType":"uint256","name":"eyewearAndGlasses","type":"uint256"},{"internalType":"uint256","name":"hairstyleAndHats","type":"uint256"},{"internalType":"uint256","name":"item","type":"uint256"}],"internalType":"struct TraitsStorage.TraitIndices","name":"indices","type":"tuple"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"mintedCombinations","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintingFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"moodCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"piercingsCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pricePerMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"uint256","name":"newPrice","type":"uint256"}],"name":"setMintingFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tokenTraits","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenID","type":"uint256"}],"name":"tokenTraitsById","outputs":[{"components":[{"internalType":"uint256","name":"background","type":"uint256"},{"internalType":"uint256","name":"mood","type":"uint256"},{"internalType":"uint256","name":"torso","type":"uint256"},{"internalType":"uint256","name":"faceSlot1","type":"uint256"},{"internalType":"uint256","name":"faceSlot2","type":"uint256"},{"internalType":"uint256","name":"piercings","type":"uint256"},{"internalType":"uint256","name":"eyewearAndGlasses","type":"uint256"},{"internalType":"uint256","name":"hairstyleAndHats","type":"uint256"},{"internalType":"uint256","name":"item","type":"uint256"}],"internalType":"struct TraitsStorage.TraitIndices","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenUriSetter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"torsoCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"transferAdmin","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":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000b166e8b140d35d9d8226e40c09f757bac5a4d87d0000000000000000000000005bd5654d2b0e5bcad5d33e926c279a2a58b8229b

-----Decoded View---------------
Arg [0] : erc20TokenAddress_ (address): 0xB166E8B140D35D9D8226E40C09f757BAC5A4d87d
Arg [1] : tokenUriSetter_ (address): 0x5Bd5654D2B0E5BCAD5d33E926c279A2A58B8229B

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000b166e8b140d35d9d8226e40c09f757bac5a4d87d
Arg [1] : 0000000000000000000000005bd5654d2b0e5bcad5d33e926c279a2a58b8229b

91362:4134:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74397:210;;;;;;;;;;-1:-1:-1;74397:210:0;;;;;:::i;:::-;;:::i;:::-;;95263:230;;;;;;;;;;-1:-1:-1;95263:230:0;;;;;:::i;:::-;;:::i;:::-;;;2113:14:1;;2106:22;2088:41;;2076:2;2061:18;95263:230:0;;;;;;;;53578:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;54838:199::-;;;;;;;;;;-1:-1:-1;54838:199:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;3245:32:1;;;3227:51;;3215:2;3200:18;54838:199:0;3081:203:1;54657:115:0;;;;;;;;;;-1:-1:-1;54657:115:0;;;;;:::i;:::-;;:::i;85650:29::-;;;;;;;;;;;;;;;;;;;3872:25:1;;;3860:2;3845:18;85650:29:0;3726:177:1;94283:99:0;;;;;;;;;;-1:-1:-1;94353:21:0;94283:99;;76701:104;;;;;;;;;;-1:-1:-1;76780:10:0;:17;76701:104;;93901:101;;;;;;;;;;-1:-1:-1;93976:18:0;;-1:-1:-1;;;;;93976:18:0;93901:101;;91681:25;;;;;;;;;;;;;;;;94111:164;;;;;;;;;;-1:-1:-1;94111:164:0;;;;;:::i;:::-;;:::i;55589:622::-;;;;;;;;;;-1:-1:-1;55589:622:0;;;;;:::i;:::-;;:::i;76324:301::-;;;;;;;;;;-1:-1:-1;76324:301:0;;;;;:::i;:::-;;:::i;85722:29::-;;;;;;;;;;;;;;;;85758:37;;;;;;;;;;;;;;;;89845:328;;;;;;;;;;-1:-1:-1;89845:328:0;;;;;:::i;:::-;;:::i;92387:65::-;;;;;;;;;;;;;:::i;56282:168::-;;;;;;;;;;-1:-1:-1;56282:168:0;;;;;:::i;:::-;;:::i;70817:318::-;;;;;;;;;;-1:-1:-1;70817:318:0;;;;;:::i;:::-;;:::i;85581:30::-;;;;;;;;;;;;;;;;88522:335;;;;;;;;;;-1:-1:-1;88522:335:0;;;;;:::i;:::-;;:::i;91747:29::-;;;;;;;;;;-1:-1:-1;91747:29:0;;;;-1:-1:-1;;;;;91747:29:0;;;76882:231;;;;;;;;;;-1:-1:-1;76882:231:0;;;;;:::i;:::-;;:::i;87718:204::-;;;;;;;;;;-1:-1:-1;87718:204:0;;;;;:::i;:::-;;:::i;91713:25::-;;;;;;;;;;;;;;;;39130:86;;;;;;;;;;-1:-1:-1;39201:7:0;;;;39130:86;;53391:120;;;;;;;;;;-1:-1:-1;53391:120:0;;;;;:::i;:::-;;:::i;53116:213::-;;;;;;;;;;-1:-1:-1;53116:213:0;;;;;:::i;:::-;;:::i;33797:103::-;;;;;;;;;;;;;:::i;36674:210::-;;;;;;;;;;-1:-1:-1;36674:210:0;;;;;:::i;:::-;;:::i;89173:328::-;;;;;;;;;;-1:-1:-1;89173:328:0;;;;;:::i;:::-;;:::i;92460:1204::-;;;;;;:::i;:::-;;:::i;92318:61::-;;;;;;;;;;;;;:::i;33122:87::-;;;;;;;;;;-1:-1:-1;33195:6:0;;-1:-1:-1;;;;;33195:6:0;33122:87;;53738:95;;;;;;;;;;;;;:::i;87930:190::-;;;;;;;;;;-1:-1:-1;87930:190:0;;;;;:::i;:::-;;:::i;:::-;;;;;;6287:4:1;6329:3;6318:9;6314:19;6306:27;;6366:6;6360:13;6349:9;6342:32;6430:4;6422:6;6418:17;6412:24;6405:4;6394:9;6390:20;6383:54;6493:4;6485:6;6481:17;6475:24;6468:4;6457:9;6453:20;6446:54;6556:4;6548:6;6544:17;6538:24;6531:4;6520:9;6516:20;6509:54;6619:4;6611:6;6607:17;6601:24;6594:4;6583:9;6579:20;6572:54;6682:4;6674:6;6670:17;6664:24;6657:4;6646:9;6642:20;6635:54;6745:4;6737:6;6733:17;6727:24;6720:4;6709:9;6705:20;6698:54;6808:4;6800:6;6796:17;6790:24;6783:4;6772:9;6768:20;6761:54;6834:6;6894:2;6886:6;6882:15;6876:22;6871:2;6860:9;6856:18;6849:50;;6135:770;;;;;88865:300:0;;;;;;;;;;-1:-1:-1;88865:300:0;;;;;:::i;:::-;;:::i;55109:146::-;;;;;;;;;;-1:-1:-1;55109:146:0;;;;;:::i;:::-;;:::i;91028:299::-;;;;;;;;;;-1:-1:-1;91028:299:0;;;;;:::i;:::-;;:::i;85802:37::-;;;;;;;;;;;;;;;;90181:416;;;;;;;;;;-1:-1:-1;90181:416:0;;;;;:::i;:::-;;:::i;56521:254::-;;;;;;;;;;-1:-1:-1;56521:254:0;;;;;:::i;:::-;;:::i;89509:328::-;;;;;;;;;;-1:-1:-1;89509:328:0;;;;;:::i;:::-;;:::i;94010:93::-;;;;;;;;;;-1:-1:-1;94082:13:0;;94010:93;;95059:196;;;;;;;;;;-1:-1:-1;95059:196:0;;;;;:::i;:::-;;:::i;85686:29::-;;;;;;;;;;;;;;;;90605:415;;;;;;;;;;-1:-1:-1;90605:415:0;;;;;:::i;:::-;;:::i;86527:44::-;;;;;;;;;;-1:-1:-1;86527:44:0;;;;;:::i;:::-;;:::i;85550:24::-;;;;;;;;;;;;;;;;85846:25;;;;;;;;;;;;;;;;86470:50;;;;;;;;;;-1:-1:-1;86470:50:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;55326:196;;;;;;;;;;-1:-1:-1;55326:196:0;;;;;:::i;:::-;;:::i;85618:25::-;;;;;;;;;;;;;;;;34055:220;;;;;;;;;;-1:-1:-1;34055:220:0;;;;;:::i;:::-;;:::i;36190:87::-;;;;;;;;;;-1:-1:-1;36263:6:0;;-1:-1:-1;;;;;36263:6:0;36190:87;;74397:210;36076:13;:11;:13::i;:::-;74529:19:::1;::::0;;;:10:::1;:19;::::0;;;;:31:::1;74551:9:::0;74529:19;:31:::1;:::i;:::-;-1:-1:-1::0;74576:23:0::1;::::0;3872:25:1;;;74576:23:0::1;::::0;3860:2:1;3845:18;74576:23:0::1;;;;;;;74397:210:::0;;:::o;95263:230::-;95420:4;95449:36;95473:11;95449:23;:36::i;:::-;95442:43;95263:230;-1:-1:-1;;95263:230:0:o;53578:91::-;53623:13;53656:5;53649:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53578:91;:::o;54838:199::-;54941:7;54966:22;54980:7;54966:13;:22::i;:::-;-1:-1:-1;57643:7:0;57675:24;;;:15;:24;;;;;;-1:-1:-1;;;;;57675:24:0;55008:21;57537:170;54657:115;54729:35;54738:2;54742:7;31297:10;54729:8;:35::i;:::-;54657:115;;:::o;94111:164::-;33008:13;:11;:13::i;:::-;94201:1:::1;94190:8;:12;94182:53;;;::::0;-1:-1:-1;;;94182:53:0;;11332:2:1;94182:53:0::1;::::0;::::1;11314:21:1::0;11371:2;11351:18;;;11344:30;11410;11390:18;;;11383:58;11458:18;;94182:53:0::1;;;;;;;;;94246:10;:21:::0;94111:164::o;55589:622::-;-1:-1:-1;;;;;55718:16:0;;55714:89;;55758:33;;-1:-1:-1;;;55758:33:0;;55788:1;55758:33;;;3227:51:1;3200:18;;55758:33:0;3081:203:1;55714:89:0;56024:21;56048:34;56056:2;56060:7;31297:10;56048:7;:34::i;:::-;56024:58;;56114:4;-1:-1:-1;;;;;56097:21:0;:13;-1:-1:-1;;;;;56097:21:0;;56093:111;;56142:50;;-1:-1:-1;;;56142:50:0;;-1:-1:-1;;;;;11745:15:1;;;56142:50:0;;;11727:34:1;11777:18;;;11770:34;;;11840:15;;11820:18;;;11813:43;11662:18;;56142:50:0;11487:375:1;56093:111:0;55703:508;55589:622;;;:::o;76324:301::-;76448:7;76486:16;76496:5;76486:9;:16::i;:::-;76477:5;:25;76473:101;;76526:36;;-1:-1:-1;;;76526:36:0;;-1:-1:-1;;;;;12059:32:1;;76526:36:0;;;12041:51:1;12108:18;;;12101:34;;;12014:18;;76526:36:0;11867:274:1;76473:101:0;-1:-1:-1;;;;;;76591:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;76324:301::o;89845:328::-;89908:7;33008:13;:11;:13::i;:::-;89932:6:::1;89928:206;;;89972:14;::::0;:18:::1;::::0;89989:1:::1;89972:18;:::i;:::-;89955:14;:35:::0;89928:206:::1;;;90048:1;90031:14;;:18;90023:49;;;;-1:-1:-1::0;;;90023:49:0::1;;;;;;;:::i;:::-;90121:1;90104:14;;:18;;;;:::i;:::-;90087:14;:35:::0;89928:206:::1;-1:-1:-1::0;90151:14:0::1;::::0;33032:1:::1;89845:328:::0;;;:::o;92387:65::-;33008:13;:11;:13::i;:::-;92434:10:::1;:8;:10::i;:::-;92387:65::o:0;56282:168::-;56403:39;56420:4;56426:2;56430:7;56403:39;;;;;;;;;;;;:16;:39::i;:::-;56282:168;;;:::o;70817:318::-;71085:42;71101:1;71105:7;31297:10;56048:7;:34::i;88522:335::-;88586:7;33008:13;:11;:13::i;:::-;88610:6:::1;88606:211;;;88651:15;::::0;:19:::1;::::0;88669:1:::1;88651:19;:::i;:::-;88633:15;:37:::0;88606:211:::1;;;88729:1;88711:15;;:19;88703:50;;;;-1:-1:-1::0;;;88703:50:0::1;;;;;;;:::i;:::-;88804:1;88786:15;;:19;;;;:::i;:::-;88768:15;:37:::0;88606:211:::1;-1:-1:-1::0;;88834:15:0::1;::::0;;88522:335::o;76882:231::-;76948:7;76981:13;76780:10;:17;;76701:104;76981:13;76972:5;:22;76968:103;;77018:41;;-1:-1:-1;;;77018:41:0;;77049:1;77018:41;;;12041:51:1;12108:18;;;12101:34;;;12014:18;;77018:41:0;11867:274:1;76968:103:0;77088:10;77099:5;77088:17;;;;;;;;:::i;:::-;;;;;;;;;77081:24;;76882:231;;;:::o;87718:204::-;87786:4;87803:23;87829:32;87853:7;87829:23;:32::i;:::-;87879:35;;;;:18;:35;;;;;;;;;87718:204;-1:-1:-1;;;87718:204:0:o;53391:120::-;53454:7;53481:22;53495:7;53481:13;:22::i;53116:213::-;53179:7;-1:-1:-1;;;;;53203:19:0;;53199:89;;53246:30;;-1:-1:-1;;;53246:30:0;;53273:1;53246:30;;;3227:51:1;3200:18;;53246:30:0;3081:203:1;53199:89:0;-1:-1:-1;;;;;;53305:16:0;;;;;:9;:16;;;;;;;53116:213::o;33797:103::-;33008:13;:11;:13::i;:::-;33862:30:::1;33889:1;33862:18;:30::i;36674:210::-:0;33008:13;:11;:13::i;:::-;-1:-1:-1;;;;;36755:22:0;::::1;36751:91;;36801:29;::::0;-1:-1:-1;;;36801:29:0;;36827:1:::1;36801:29;::::0;::::1;3227:51:1::0;3200:18;;36801:29:0::1;3081:203:1::0;36751:91:0::1;36852:24;36867:8;36852:14;:24::i;:::-;36674:210:::0;:::o;89173:328::-;89236:7;33008:13;:11;:13::i;:::-;89260:6:::1;89256:206;;;89300:14;::::0;:18:::1;::::0;89317:1:::1;89300:18;:::i;:::-;89283:14;:35:::0;89256:206:::1;;;89376:1;89359:14;;:18;89351:49;;;;-1:-1:-1::0;;;89351:49:0::1;;;;;;;:::i;:::-;89449:1;89432:14;;:18;;;;:::i;:::-;89415:14;:35:::0;89256:206:::1;-1:-1:-1::0;;89479:14:0::1;::::0;;89173:328::o;92460:1204::-;84535:21;:19;:21::i;:::-;92621:10:::1;;92608:9;:23;92586:112;;;::::0;-1:-1:-1;;;92586:112:0;;13222:2:1;92586:112:0::1;::::0;::::1;13204:21:1::0;13261:2;13241:18;;;13234:30;13300:34;13280:18;;;13273:62;-1:-1:-1;;;13351:18:1;;;13344:37;13398:19;;92586:112:0::1;13020:403:1::0;92586:112:0::1;92738:15;::::0;92717:18;;:36:::1;92709:56;;;;-1:-1:-1::0;;;92709:56:0::1;;;;;;;:::i;:::-;92799:9;;92784:7;:12;;;:24;92776:44;;;;-1:-1:-1::0;;;92776:44:0::1;;;;;;;:::i;:::-;92855:10;;92839:7;:13;;;:26;92831:46;;;;-1:-1:-1::0;;;92831:46:0::1;;;;;;;:::i;:::-;92916:14;;92896:7;:17;;;:34;92888:54;;;;-1:-1:-1::0;;;92888:54:0::1;;;;;;;:::i;:::-;92981:14;;92961:7;:17;;;:34;92953:54;;;;-1:-1:-1::0;;;92953:54:0::1;;;;;;;:::i;:::-;93046:14;;93026:7;:17;;;:34;93018:54;;;;-1:-1:-1::0;;;93018:54:0::1;;;;;;;:::i;:::-;93119:22;;93091:7;:25;;;:50;93083:70;;;;-1:-1:-1::0;;;93083:70:0::1;;;;;;;:::i;:::-;93199:22;;93172:7;:24;;;:49;93164:69;;;;-1:-1:-1::0;;;93164:69:0::1;;;;;;;:::i;:::-;93267:10;;93252:7;:12;;;:25;93244:45;;;;-1:-1:-1::0;;;93244:45:0::1;;;;;;;:::i;:::-;93323:10;::::0;93304:12:::1;::::0;:16:::1;::::0;93319:1:::1;93304:16;:::i;:::-;:29;93300:43;;;93335:8;::::0;::::1;93300:43;93372:12;:14:::0;;93354:15:::1;::::0;;93372:14:::1;::::0;::::1;:::i;:::-;;;;;93354:32;;93397:14;:12;:14::i;:::-;93422:20;:18;:20::i;:::-;93453:23;93479:32;93503:7;93479:23;:32::i;:::-;93453:58;;93522:65;93553:15;93570:7;93579;93522:30;:65::i;:::-;93598:22;93608:2;93612:7;93598:9;:22::i;:::-;93636:20;::::0;3872:25:1;;;93636:20:0::1;::::0;3860:2:1;3845:18;93636:20:0::1;;;;;;;92575:1089;;84579:20:::0;83870:1;85121:7;:21;84938:212;92318:61;33008:13;:11;:13::i;:::-;92363:8:::1;:6;:8::i;53738:95::-:0;53785:13;53818:7;53811:14;;;;;:::i;87930:190::-;88020:19;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88020:19:0;88075:20;;;;:11;:20;;;;;88064:48;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;88865:300::-;88924:7;33008:13;:11;:13::i;:::-;88948:6:::1;88944:186;;;88984:10;::::0;:14:::1;::::0;88997:1:::1;88984:14;:::i;:::-;88971:10;:27:::0;88944:186:::1;;;89052:1;89039:10;;:14;89031:45;;;;-1:-1:-1::0;;;89031:45:0::1;;;;;;;:::i;:::-;89117:1;89104:10;;:14;;;;:::i;:::-;89091:10;:27:::0;88944:186:::1;-1:-1:-1::0;;89147:10:0::1;::::0;;88865:300::o;55109:146::-;55195:52;31297:10;55228:8;55238;55195:18;:52::i;91028:299::-;91086:7;33008:13;:11;:13::i;:::-;91110:6:::1;91106:186;;;91146:10;::::0;:14:::1;::::0;91159:1:::1;91146:14;:::i;:::-;91133:10;:27:::0;91106:186:::1;;;91214:1;91201:10;;:14;91193:45;;;;-1:-1:-1::0;;;91193:45:0::1;;;;;;;:::i;:::-;91279:1;91266:10;;:14;;;;:::i;:::-;91253:10;:27:::0;91106:186:::1;-1:-1:-1::0;;91309:10:0::1;::::0;;91028:299::o;90181:416::-;90279:7;33008:13;:11;:13::i;:::-;90308:6:::1;90304:246;;;90356:22;::::0;:26:::1;::::0;90381:1:::1;90356:26;:::i;:::-;90331:22;:51:::0;90304:246:::1;;;90448:1;90423:22;;:26;90415:57;;;;-1:-1:-1::0;;;90415:57:0::1;;;;;;;:::i;:::-;90537:1;90512:22;;:26;;;;:::i;:::-;90487:22;:51:::0;90304:246:::1;-1:-1:-1::0;;90567:22:0::1;::::0;;90181:416::o;56521:254::-;56678:31;56691:4;56697:2;56701:7;56678:12;:31::i;:::-;56720:47;56743:4;56749:2;56753:7;56762:4;56720:22;:47::i;89509:328::-;89572:7;33008:13;:11;:13::i;:::-;89596:6:::1;89592:206;;;89636:14;::::0;:18:::1;::::0;89653:1:::1;89636:18;:::i;:::-;89619:14;:35:::0;89592:206:::1;;;89712:1;89695:14;;:18;89687:49;;;;-1:-1:-1::0;;;89687:49:0::1;;;;;;;:::i;:::-;89785:1;89768:14;;:18;;;;:::i;:::-;89751:14;:35:::0;89592:206:::1;-1:-1:-1::0;;89815:14:0::1;::::0;;89509:328::o;95059:196::-;95186:13;95224:23;95239:7;95224:14;:23::i;90605:415::-;90702:7;33008:13;:11;:13::i;:::-;90731:6:::1;90727:246;;;90779:22;::::0;:26:::1;::::0;90804:1:::1;90779:26;:::i;:::-;90754:22;:51:::0;90727:246:::1;;;90871:1;90846:22;;:26;90838:57;;;;-1:-1:-1::0;;;90838:57:0::1;;;;;;;:::i;:::-;90960:1;90935:22;;:26;;;;:::i;:::-;90910:22;:51:::0;90727:246:::1;-1:-1:-1::0;;90990:22:0::1;::::0;;90605:415::o;86527:44::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;55326:196::-;-1:-1:-1;;;;;55479:25:0;;;55450:4;55479:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;55326:196::o;34055:220::-;33008:13;:11;:13::i;:::-;-1:-1:-1;;;;;34140:22:0;::::1;34136:93;;34186:31;::::0;-1:-1:-1;;;34186:31:0;;34214:1:::1;34186:31;::::0;::::1;3227:51:1::0;3200:18;;34186:31:0::1;3081:203:1::0;34136:93:0::1;34239:28;34258:8;34239:18;:28::i;36355:164::-:0;36263:6;;-1:-1:-1;;;;;36263:6:0;31297:10;36415:23;36411:101;;36462:38;;-1:-1:-1;;;36462:38:0;;31297:10;36462:38;;;3227:51:1;3200:18;;36462:38:0;3081:203:1;73256:285:0;73403:4;-1:-1:-1;;;;;;73445:35:0;;-1:-1:-1;;;73445:35:0;;:88;;;73497:36;73521:11;73497:23;:36::i;68505:247::-;68568:7;57392:16;;;:7;:16;;;;;;-1:-1:-1;;;;;57392:16:0;;68632:90;;68679:31;;-1:-1:-1;;;68679:31:0;;;;;3872:25:1;;;3845:18;;68679:31:0;3726:177:1;66560:156:0;66675:33;66684:2;66688:7;66697:4;66703;66675:8;:33::i;33287:166::-;33195:6;;-1:-1:-1;;;;;33195:6:0;31297:10;33347:23;33343:103;;33394:40;;-1:-1:-1;;;33394:40:0;;31297:10;33394:40;;;3227:51:1;3200:18;;33394:40:0;3081:203:1;94599:262:0;94789:7;94821:32;94835:2;94839:7;94848:4;94821:13;:32::i;:::-;94814:39;94599:262;-1:-1:-1;;;;94599:262:0:o;40031:120::-;38994:16;:14;:16::i;:::-;40090:7:::1;:15:::0;;-1:-1:-1;;40090:15:0::1;::::0;;40121:22:::1;31297:10:::0;40130:12:::1;40121:22;::::0;-1:-1:-1;;;;;3245:32:1;;;3227:51;;3215:2;3200:18;40121:22:0::1;;;;;;;40031:120::o:0;86580:599::-;86798:18;;86839:12;;;;;86874:13;;;;;86910:17;;;;86950;;;;86990;;;;87030:25;;;;87078:24;;;;87125:12;;;;86765:391;;86692:7;;86765:391;;86798:18;;86839:12;87125;86765:391;15056:25:1;;;15112:2;15097:18;;15090:34;;;;15155:2;15140:18;;15133:34;;;;15198:2;15183:18;;15176:34;;;;15241:3;15226:19;;15219:35;;;;15285:3;15270:19;;15263:35;15329:3;15314:19;;15307:35;15373:3;15358:19;;15351:35;15417:3;15402:19;;15395:35;15043:3;15028:19;;14685:751;86765:391:0;;;;;;;;;;;;;86737:434;;;;;;86717:454;;86580:599;;;:::o;34435:191::-;34528:6;;;-1:-1:-1;;;;;34545:17:0;;;-1:-1:-1;;;;;;34545:17:0;;;;;;;34578:40;;34528:6;;;34545:17;34528:6;;34578:40;;34509:16;;34578:40;34498:128;34435:191;:::o;37044:183::-;37133:6;;;-1:-1:-1;;;;;37150:17:0;;;-1:-1:-1;;;;;;37150:17:0;;;;;;;37183:36;;37133:6;;;37150:17;37133:6;;37183:36;;37114:16;;37183:36;37103:124;37044:183;:::o;84615:315::-;83913:1;84744:7;;:18;84740:88;;84786:30;;-1:-1:-1;;;84786:30:0;;;;;;;;;;;84740:88;83913:1;84905:7;:17;84615:315::o;93672:221::-;93723:18;;93861:13;;93716:169;;-1:-1:-1;;;93716:169:0;;93770:10;93716:169;;;15681:34:1;93803:42:0;15731:18:1;;;15724:43;15783:18;;;15776:34;;;;-1:-1:-1;;;;;93723:18:0;;;;93716:39;;15616:18:1;;93716:169:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;94390:131::-;94440:18;94469:7;36263:6;;-1:-1:-1;;;;;36263:6:0;;36190:87;94469:7;94440:37;-1:-1:-1;;;;;;94488:11:0;;:25;94353:21;94488:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88128:386;88314:35;;;;:18;:35;;;;;;;;88313:36;88305:68;;;;-1:-1:-1;;;88305:68:0;;16273:2:1;88305:68:0;;;16255:21:1;16312:2;16292:18;;;16285:30;-1:-1:-1;;;16331:18:1;;;16324:49;16390:18;;88305:68:0;16071:343:1;88305:68:0;88384:35;;;;:18;:35;;;;;:42;;-1:-1:-1;;88384:42:0;88422:4;88384:42;;;88460:46;88486:19;88460:25;:46::i;:::-;88437:20;;;;:11;:20;;;;;;:69;;:20;:69;:::i;62534:102::-;62602:26;62612:2;62616:7;62602:26;;;;;;;;;;;;:9;:26::i;39772:118::-;38735:19;:17;:19::i;:::-;39832:7:::1;:14:::0;;-1:-1:-1;;39832:14:0::1;39842:4;39832:14;::::0;;39862:20:::1;39869:12;31297:10:::0;;31217:98;67910:352;-1:-1:-1;;;;;68052:22:0;;68048:93;;68098:31;;-1:-1:-1;;;68098:31:0;;-1:-1:-1;;;;;3245:32:1;;68098:31:0;;;3227:51:1;3200:18;;68098:31:0;3081:203:1;68048:93:0;-1:-1:-1;;;;;68151:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;68151:46:0;;;;;;;;;;68213:41;;2088::1;;;68213::0;;2061:18:1;68213:41:0;;;;;;;67910:352;;;:::o;69302:975::-;-1:-1:-1;;;;;69462:14:0;;;:18;69458:812;;69518:174;;-1:-1:-1;;;69518:174:0;;-1:-1:-1;;;;;69518:36:0;;;;;:174;;31297:10;;69612:4;;69639:7;;69669:4;;69518:174;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69518:174:0;;;;;;;;-1:-1:-1;;69518:174:0;;;;;;;;;;;;:::i;:::-;;;69497:762;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69948:6;:13;69965:1;69948:18;69944:300;;69998:25;;-1:-1:-1;;;69998:25:0;;-1:-1:-1;;;;;3245:32:1;;69998:25:0;;;3227:51:1;3200:18;;69998:25:0;3081:203:1;69944:300:0;70194:6;70188:13;70179:6;70175:2;70171:15;70164:38;69497:762;-1:-1:-1;;;;;;69753:51:0;;-1:-1:-1;;;69753:51:0;69749:132;;69836:25;;-1:-1:-1;;;69836:25:0;;-1:-1:-1;;;;;3245:32:1;;69836:25:0;;;3227:51:1;3200:18;;69836:25:0;3081:203:1;69749:132:0;69706:190;69302:975;;;;:::o;73612:659::-;73730:13;73761:22;73775:7;73761:13;:22::i;:::-;-1:-1:-1;73796:23:0;73822:19;;;:10;:19;;;;;73796:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73852:18;73873:10;54578:9;;;;;;;;;-1:-1:-1;54578:9:0;;;54501:94;73873:10;73852:31;;73965:4;73959:18;73981:1;73959:23;73955:72;;-1:-1:-1;74006:9:0;73612:659;-1:-1:-1;;73612:659:0:o;73955:72::-;74128:23;;:27;74124:97;;74193:4;74199:9;74179:30;;;;;;;;;:::i;:::-;;;;;;;;;;;;;74172:37;;;;73612:659;;;:::o;74124:97::-;74240:23;74255:7;74240:14;:23::i;75940:300::-;76087:4;-1:-1:-1;;;;;;76129:50:0;;-1:-1:-1;;;76129:50:0;;:103;;;76196:36;76220:11;76196:23;:36::i;66904:787::-;67109:9;:31;;;-1:-1:-1;;;;;;67122:18:0;;;;67109:31;67105:537;;;67157:13;67173:22;67187:7;67173:13;:22::i;:::-;67157:38;-1:-1:-1;;;;;;67344:18:0;;;;;;:52;;;67392:4;-1:-1:-1;;;;;67383:13:0;:5;-1:-1:-1;;;;;67383:13:0;;;67344:52;:103;;;;;67418:29;67435:5;67442:4;67418:16;:29::i;:::-;67417:30;67344:103;67322:210;;;67489:27;;-1:-1:-1;;;67489:27:0;;-1:-1:-1;;;;;3245:32:1;;67489:27:0;;;3227:51:1;3200:18;;67489:27:0;3081:203:1;67322:210:0;67552:9;67548:83;;;67607:7;67603:2;-1:-1:-1;;;;;67587:28:0;67596:5;-1:-1:-1;;;;;67587:28:0;;;;;;;;;;;67548:83;67142:500;67105:537;-1:-1:-1;;67654:24:0;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;67654:29:0;-1:-1:-1;;;;;67654:29:0;;;;;;;;;;66904:787::o;72241:210::-;72384:7;38735:19;:17;:19::i;:::-;72411:32:::1;72425:2;72429:7;72438:4;72411:13;:32::i;39498:130::-:0;39201:7;;;;39557:64;;39594:15;;-1:-1:-1;;;39594:15:0;;;;;;;;;;;87187:523;87301:12;87380:7;:18;;;87417:7;:12;;;87448:7;:13;;;87480:7;:17;;;87516:7;:17;;;87552:7;:17;;;87588:7;:25;;;87632:7;:24;;;87675:7;:12;;;87351:351;;;;;;;;;;;;;;;15056:25:1;;;15112:2;15097:18;;15090:34;;;;15155:2;15140:18;;15133:34;;;;15198:2;15183:18;;15176:34;;;;15241:3;15226:19;;15219:35;;;;15285:3;15270:19;;15263:35;15329:3;15314:19;;15307:35;15373:3;15358:19;;15351:35;15417:3;15402:19;;15395:35;15043:3;15028:19;;14685:751;87351:351:0;;;;;;;;;;;;;87331:371;;87187:523;;;:::o;62863:219::-;62992:18;62998:2;63002:7;62992:5;:18::i;:::-;63021:53;63052:1;63056:2;63060:7;63069:4;63021:22;:53::i;39289:132::-;39201:7;;;;39351:63;;;39387:15;;-1:-1:-1;;;39387:15:0;;;;;;;;;;;53904:348;54004:13;54035:22;54049:7;54035:13;:22::i;:::-;;54070:21;54094:10;54578:9;;;;;;;;;-1:-1:-1;54578:9:0;;;54501:94;54094:10;54070:34;;54159:1;54141:7;54135:21;:25;:109;;;;;;;;;;;;;;;;;54194:7;54203:18;:7;:16;:18::i;:::-;54180:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;54135:109;54115:129;53904:348;-1:-1:-1;;;53904:348:0:o;52697:355::-;52844:4;-1:-1:-1;;;;;;52886:40:0;;-1:-1:-1;;;52886:40:0;;:105;;-1:-1:-1;;;;;;;52943:48:0;;-1:-1:-1;;;52943:48:0;52886:105;:158;;;-1:-1:-1;;;;;;;;;;43231:40:0;;;53008:36;43090:189;77174:674;77303:7;77323:21;77347:32;77361:2;77365:7;77374:4;77347:13;:32::i;:::-;77323:56;-1:-1:-1;;;;;;77396:27:0;;77392:214;;77440:40;77472:7;78672:10;:17;;78645:24;;;;:15;:24;;;;;:44;;;78700:24;;;;;;;;;;;;78568:164;77440:40;77392:214;;;77519:2;-1:-1:-1;;;;;77502:19:0;:13;-1:-1:-1;;;;;77502:19:0;;77498:108;;77538:56;77571:13;77586:7;77538:32;:56::i;:::-;-1:-1:-1;;;;;77620:16:0;;77616:192;;77653:45;77690:7;77653:36;:45::i;:::-;77616:192;;;77737:2;-1:-1:-1;;;;;77720:19:0;:13;-1:-1:-1;;;;;77720:19:0;;77716:92;;77756:40;77784:2;77788:7;77756:27;:40::i;61836:335::-;-1:-1:-1;;;;;61904:16:0;;61900:89;;61944:33;;-1:-1:-1;;;61944:33:0;;61974:1;61944:33;;;3227:51:1;3200:18;;61944:33:0;3081:203:1;61900:89:0;61999:21;62023:32;62031:2;62035:7;62052:1;62023:7;:32::i;:::-;61999:56;-1:-1:-1;;;;;;62070:27:0;;;62066:98;;62121:31;;-1:-1:-1;;;62121:31:0;;62149:1;62121:31;;;3227:51:1;3200:18;;62121:31:0;3081:203:1;27805:718:0;27861:13;27912:14;27929:17;27940:5;27929:10;:17::i;:::-;27949:1;27929:21;27912:38;;27965:20;27999:6;27988:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27988:18:0;-1:-1:-1;27965:41:0;-1:-1:-1;28130:28:0;;;28146:2;28130:28;28187:290;-1:-1:-1;;28219:5:0;-1:-1:-1;;;28356:2:0;28345:14;;28340:32;28219:5;28327:46;28419:2;28410:11;;;-1:-1:-1;28440:21:0;28187:290;28440:21;-1:-1:-1;28498:6:0;27805:718;-1:-1:-1;;;27805:718:0:o;60642:858::-;60762:7;57392:16;;;:7;:16;;;;;;-1:-1:-1;;;;;57392:16:0;;;;60877:18;;;60873:88;;60912:37;60929:4;60935;60941:7;60912:16;:37::i;:::-;-1:-1:-1;;;;;61008:18:0;;;61004:263;;61126:48;61143:1;61147:7;61164:1;61168:5;61126:8;:48::i;:::-;-1:-1:-1;;;;;61220:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;61220:20:0;;;61004:263;-1:-1:-1;;;;;61283:16:0;;;61279:111;;-1:-1:-1;;;;;61345:13:0;;;;;;:9;:13;;;;;:18;;61362:1;61345:18;;;61279:111;61402:16;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;61402:21:0;-1:-1:-1;;;;;61402:21:0;;;;;;;;;61441:27;;61402:16;;61441:27;;;;;;;61488:4;60642:858;-1:-1:-1;;;;60642:858:0:o;79359:991::-;79639:22;79664:15;79674:4;79664:9;:15::i;:::-;79690:18;79711:26;;;:17;:26;;;;;;79639:40;;-1:-1:-1;79844:28:0;;;79840:328;;-1:-1:-1;;;;;79911:18:0;;79889:19;79911:18;;;:12;:18;;;;;;;;:34;;;;;;;;;79962:30;;;;;;:44;;;80079:30;;:17;:30;;;;;:43;;;79840:328;-1:-1:-1;80264:26:0;;;;:17;:26;;;;;;;;80257:33;;;-1:-1:-1;;;;;80308:18:0;;;;;:12;:18;;;;;:34;;;;;;;80301:41;79359:991::o;80645:1079::-;80923:10;:17;80898:22;;80923:21;;80943:1;;80923:21;:::i;:::-;80955:18;80976:24;;;:15;:24;;;;;;81349:10;:26;;80898:46;;-1:-1:-1;80976:24:0;;80898:46;;81349:26;;;;;;:::i;:::-;;;;;;;;;81327:48;;81413:11;81388:10;81399;81388:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;81493:28;;;:15;:28;;;;;;;:41;;;81665:24;;;;;81658:31;81700:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;80716:1008;;;80645:1079;:::o;78149:218::-;78234:14;78267:1;78251:13;78261:2;78251:9;:13::i;:::-;:17;;;;:::i;:::-;-1:-1:-1;;;;;78279:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;78324:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;78149:218:0:o;24021:922::-;24074:7;;-1:-1:-1;;;24152:15:0;;24148:102;;-1:-1:-1;;;24188:15:0;;;-1:-1:-1;24232:2:0;24222:12;24148:102;24277:6;24268:5;:15;24264:102;;24313:6;24304:15;;;-1:-1:-1;24348:2:0;24338:12;24264:102;24393:6;24384:5;:15;24380:102;;24429:6;24420:15;;;-1:-1:-1;24464:2:0;24454:12;24380:102;24509:5;24500;:14;24496:99;;24544:5;24535:14;;;-1:-1:-1;24578:1:0;24568:11;24496:99;24622:5;24613;:14;24609:99;;24657:5;24648:14;;;-1:-1:-1;24691:1:0;24681:11;24609:99;24735:5;24726;:14;24722:99;;24770:5;24761:14;;;-1:-1:-1;24804:1:0;24794:11;24722:99;24848:5;24839;:14;24835:66;;24884:1;24874:11;24929:6;24021:922;-1:-1:-1;;24021:922:0:o;58815:410::-;58962:38;58976:5;58983:7;58992;58962:13;:38::i;:::-;58957:261;;-1:-1:-1;;;;;59021:19:0;;59017:190;;59068:31;;-1:-1:-1;;;59068:31:0;;;;;3872:25:1;;;3845:18;;59068:31:0;3726:177:1;59017:190:0;59147:44;;-1:-1:-1;;;59147:44:0;;-1:-1:-1;;;;;12059:32:1;;59147:44:0;;;12041:51:1;12108:18;;;12101:34;;;12014:18;;59147:44:0;11867:274:1;58027:344:0;58164:4;-1:-1:-1;;;;;58201:21:0;;;;;;:162;;;58249:7;-1:-1:-1;;;;;58240:16:0;:5;-1:-1:-1;;;;;58240:16:0;;:69;;;;58277:32;58294:5;58301:7;58277:16;:32::i;:::-;58240:122;;;-1:-1:-1;;57643:7:0;57675:24;;;:15;:24;;;;;;-1:-1:-1;;;;;57675:24:0;;;58330:32;;;;;-1:-1:-1;58027:344:0:o;14:127:1:-;75:10;70:3;66:20;63:1;56:31;106:4;103:1;96:15;130:4;127:1;120:15;146:250;213:2;207:9;255:6;243:19;;292:18;277:34;;313:22;;;274:62;271:88;;;339:18;;:::i;:::-;375:2;368:22;146:250;:::o;401:632::-;466:5;496:18;537:2;529:6;526:14;523:40;;;543:18;;:::i;:::-;618:2;612:9;586:2;672:15;;-1:-1:-1;;668:24:1;;;694:2;664:33;660:42;648:55;;;718:18;;;738:22;;;715:46;712:72;;;764:18;;:::i;:::-;804:10;800:2;793:22;833:6;824:15;;863:6;855;848:22;903:3;894:6;889:3;885:16;882:25;879:45;;;920:1;917;910:12;879:45;970:6;965:3;958:4;950:6;946:17;933:44;1025:1;1018:4;1009:6;1001;997:19;993:30;986:41;;;;401:632;;;;;:::o;1038:519::-;1116:6;1124;1177:2;1165:9;1156:7;1152:23;1148:32;1145:52;;;1193:1;1190;1183:12;1145:52;1229:9;1216:23;1206:33;;1290:2;1279:9;1275:18;1262:32;1317:18;1309:6;1306:30;1303:50;;;1349:1;1346;1339:12;1303:50;1372:22;;1425:4;1417:13;;1413:27;-1:-1:-1;1403:55:1;;1454:1;1451;1444:12;1403:55;1477:74;1543:7;1538:2;1525:16;1520:2;1516;1512:11;1477:74;:::i;:::-;1467:84;;;1038:519;;;;;:::o;1562:131::-;-1:-1:-1;;;;;;1636:32:1;;1626:43;;1616:71;;1683:1;1680;1673:12;1698:245;1756:6;1809:2;1797:9;1788:7;1784:23;1780:32;1777:52;;;1825:1;1822;1815:12;1777:52;1864:9;1851:23;1883:30;1907:5;1883:30;:::i;2140:250::-;2225:1;2235:113;2249:6;2246:1;2243:13;2235:113;;;2325:11;;;2319:18;2306:11;;;2299:39;2271:2;2264:10;2235:113;;;-1:-1:-1;;2382:1:1;2364:16;;2357:27;2140:250::o;2395:271::-;2437:3;2475:5;2469:12;2502:6;2497:3;2490:19;2518:76;2587:6;2580:4;2575:3;2571:14;2564:4;2557:5;2553:16;2518:76;:::i;:::-;2648:2;2627:15;-1:-1:-1;;2623:29:1;2614:39;;;;2655:4;2610:50;;2395:271;-1:-1:-1;;2395:271:1:o;2671:220::-;2820:2;2809:9;2802:21;2783:4;2840:45;2881:2;2870:9;2866:18;2858:6;2840:45;:::i;2896:180::-;2955:6;3008:2;2996:9;2987:7;2983:23;2979:32;2976:52;;;3024:1;3021;3014:12;2976:52;-1:-1:-1;3047:23:1;;2896:180;-1:-1:-1;2896:180:1:o;3289:173::-;3357:20;;-1:-1:-1;;;;;3406:31:1;;3396:42;;3386:70;;3452:1;3449;3442:12;3467:254;3535:6;3543;3596:2;3584:9;3575:7;3571:23;3567:32;3564:52;;;3612:1;3609;3602:12;3564:52;3635:29;3654:9;3635:29;:::i;:::-;3625:39;3711:2;3696:18;;;;3683:32;;-1:-1:-1;;;3467:254:1:o;3908:328::-;3985:6;3993;4001;4054:2;4042:9;4033:7;4029:23;4025:32;4022:52;;;4070:1;4067;4060:12;4022:52;4093:29;4112:9;4093:29;:::i;:::-;4083:39;;4141:38;4175:2;4164:9;4160:18;4141:38;:::i;:::-;4131:48;;4226:2;4215:9;4211:18;4198:32;4188:42;;3908:328;;;;;:::o;4241:118::-;4327:5;4320:13;4313:21;4306:5;4303:32;4293:60;;4349:1;4346;4339:12;4364:241;4420:6;4473:2;4461:9;4452:7;4448:23;4444:32;4441:52;;;4489:1;4486;4479:12;4441:52;4528:9;4515:23;4547:28;4569:5;4547:28;:::i;4610:769::-;4669:5;4717:6;4705:9;4700:3;4696:19;4692:32;4689:52;;;4737:1;4734;4727:12;4689:52;4759:17;;:::i;:::-;4750:26;;4812:9;4799:23;4792:5;4785:38;4883:2;4872:9;4868:18;4855:32;4850:2;4843:5;4839:14;4832:56;4948:2;4937:9;4933:18;4920:32;4915:2;4908:5;4904:14;4897:56;5013:2;5002:9;4998:18;4985:32;4980:2;4973:5;4969:14;4962:56;5079:3;5068:9;5064:19;5051:33;5045:3;5038:5;5034:15;5027:58;5146:3;5135:9;5131:19;5118:33;5112:3;5105:5;5101:15;5094:58;5213:3;5202:9;5198:19;5185:33;5179:3;5172:5;5168:15;5161:58;5280:3;5269:9;5265:19;5252:33;5246:3;5239:5;5235:15;5228:58;5305:3;5368:2;5357:9;5353:18;5340:32;5335:2;5328:5;5324:14;5317:56;;4610:769;;;;:::o;5384:238::-;5473:6;5526:3;5514:9;5505:7;5501:23;5497:33;5494:53;;;5543:1;5540;5533:12;5494:53;5566:50;5608:7;5597:9;5566:50;:::i;5627:186::-;5686:6;5739:2;5727:9;5718:7;5714:23;5710:32;5707:52;;;5755:1;5752;5745:12;5707:52;5778:29;5797:9;5778:29;:::i;5818:312::-;5916:6;5924;5977:3;5965:9;5956:7;5952:23;5948:33;5945:53;;;5994:1;5991;5984:12;5945:53;6017:29;6036:9;6017:29;:::i;:::-;6007:39;;6065:59;6116:7;6111:2;6100:9;6096:18;6065:59;:::i;:::-;6055:69;;5818:312;;;;;:::o;6910:315::-;6975:6;6983;7036:2;7024:9;7015:7;7011:23;7007:32;7004:52;;;7052:1;7049;7042:12;7004:52;7075:29;7094:9;7075:29;:::i;:::-;7065:39;;7154:2;7143:9;7139:18;7126:32;7167:28;7189:5;7167:28;:::i;:::-;7214:5;7204:15;;;6910:315;;;;;:::o;7230:667::-;7325:6;7333;7341;7349;7402:3;7390:9;7381:7;7377:23;7373:33;7370:53;;;7419:1;7416;7409:12;7370:53;7442:29;7461:9;7442:29;:::i;:::-;7432:39;;7490:38;7524:2;7513:9;7509:18;7490:38;:::i;:::-;7480:48;;7575:2;7564:9;7560:18;7547:32;7537:42;;7630:2;7619:9;7615:18;7602:32;7657:18;7649:6;7646:30;7643:50;;;7689:1;7686;7679:12;7643:50;7712:22;;7765:4;7757:13;;7753:27;-1:-1:-1;7743:55:1;;7794:1;7791;7784:12;7743:55;7817:74;7883:7;7878:2;7865:16;7860:2;7856;7852:11;7817:74;:::i;:::-;7807:84;;;7230:667;;;;;;;:::o;8310:260::-;8378:6;8386;8439:2;8427:9;8418:7;8414:23;8410:32;8407:52;;;8455:1;8452;8445:12;8407:52;8478:29;8497:9;8478:29;:::i;:::-;8468:39;;8526:38;8560:2;8549:9;8545:18;8526:38;:::i;8575:380::-;8654:1;8650:12;;;;8697;;;8718:61;;8772:4;8764:6;8760:17;8750:27;;8718:61;8825:2;8817:6;8814:14;8794:18;8791:38;8788:161;;8871:10;8866:3;8862:20;8859:1;8852:31;8906:4;8903:1;8896:15;8934:4;8931:1;8924:15;8788:161;;8575:380;;;:::o;9086:518::-;9188:2;9183:3;9180:11;9177:421;;;9224:5;9221:1;9214:16;9268:4;9265:1;9255:18;9338:2;9326:10;9322:19;9319:1;9315:27;9309:4;9305:38;9374:4;9362:10;9359:20;9356:47;;;-1:-1:-1;9397:4:1;9356:47;9452:2;9447:3;9443:12;9440:1;9436:20;9430:4;9426:31;9416:41;;9507:81;9525:2;9518:5;9515:13;9507:81;;;9584:1;9570:16;;9551:1;9540:13;9507:81;;9780:1345;9906:3;9900:10;9933:18;9925:6;9922:30;9919:56;;;9955:18;;:::i;:::-;9984:97;10074:6;10034:38;10066:4;10060:11;10034:38;:::i;:::-;10028:4;9984:97;:::i;:::-;10136:4;;10193:2;10182:14;;10210:1;10205:663;;;;10912:1;10929:6;10926:89;;;-1:-1:-1;10981:19:1;;;10975:26;10926:89;-1:-1:-1;;9737:1:1;9733:11;;;9729:24;9725:29;9715:40;9761:1;9757:11;;;9712:57;11028:81;;10175:944;;10205:663;9033:1;9026:14;;;9070:4;9057:18;;-1:-1:-1;;10241:20:1;;;10359:236;10373:7;10370:1;10367:14;10359:236;;;10462:19;;;10456:26;10441:42;;10554:27;;;;10522:1;10510:14;;;;10389:19;;10359:236;;;10363:3;10623:6;10614:7;10611:19;10608:201;;;10684:19;;;10678:26;-1:-1:-1;;10767:1:1;10763:14;;;10779:3;10759:24;10755:37;10751:42;10736:58;10721:74;;10608:201;;;10855:1;10846:6;10843:1;10839:14;10835:22;10829:4;10822:36;10175:944;;;;;9780:1345;;:::o;12146:127::-;12207:10;12202:3;12198:20;12195:1;12188:31;12238:4;12235:1;12228:15;12262:4;12259:1;12252:15;12278:125;12343:9;;;12364:10;;;12361:36;;;12377:18;;:::i;12408:342::-;12610:2;12592:21;;;12649:2;12629:18;;;12622:30;-1:-1:-1;;;12683:2:1;12668:18;;12661:48;12741:2;12726:18;;12408:342::o;12755:128::-;12822:9;;;12843:11;;;12840:37;;;12857:18;;:::i;12888:127::-;12949:10;12944:3;12940:20;12937:1;12930:31;12980:4;12977:1;12970:15;13004:4;13001:1;12994:15;13428:330;13630:2;13612:21;;;13669:1;13649:18;;;13642:29;-1:-1:-1;;;13702:2:1;13687:18;;13680:37;13749:2;13734:18;;13428:330::o;13763:135::-;13802:3;13823:17;;;13820:43;;13843:18;;:::i;:::-;-1:-1:-1;13890:1:1;13879:13;;13763:135::o;13903:777::-;14003:6;14056:3;14044:9;14035:7;14031:23;14027:33;14024:53;;;14073:1;14070;14063:12;14024:53;14099:17;;:::i;:::-;14145:9;14139:16;14132:5;14125:31;14209:2;14198:9;14194:18;14188:25;14183:2;14176:5;14172:14;14165:49;14267:2;14256:9;14252:18;14246:25;14241:2;14234:5;14230:14;14223:49;14325:2;14314:9;14310:18;14304:25;14299:2;14292:5;14288:14;14281:49;14384:3;14373:9;14369:19;14363:26;14357:3;14350:5;14346:15;14339:51;14444:3;14433:9;14429:19;14423:26;14417:3;14410:5;14406:15;14399:51;14504:3;14493:9;14489:19;14483:26;14477:3;14470:5;14466:15;14459:51;14564:3;14553:9;14549:19;14543:26;14537:3;14530:5;14526:15;14519:51;14589:3;14645:2;14634:9;14630:18;14624:25;14619:2;14612:5;14608:14;14601:49;;14669:5;14659:15;;;13903:777;;;;:::o;15821:245::-;15888:6;15941:2;15929:9;15920:7;15916:23;15912:32;15909:52;;;15957:1;15954;15947:12;15909:52;15989:9;15983:16;16008:28;16030:5;16008:28;:::i;17767:489::-;-1:-1:-1;;;;;18036:15:1;;;18018:34;;18088:15;;18083:2;18068:18;;18061:43;18135:2;18120:18;;18113:34;;;18183:3;18178:2;18163:18;;18156:31;;;17961:4;;18204:46;;18230:19;;18222:6;18204:46;:::i;:::-;18196:54;17767:489;-1:-1:-1;;;;;;17767:489:1:o;18261:249::-;18330:6;18383:2;18371:9;18362:7;18358:23;18354:32;18351:52;;;18399:1;18396;18389:12;18351:52;18431:9;18425:16;18450:30;18474:5;18450:30;:::i;18515:496::-;18694:3;18732:6;18726:13;18748:66;18807:6;18802:3;18795:4;18787:6;18783:17;18748:66;:::i;:::-;18877:13;;18836:16;;;;18899:70;18877:13;18836:16;18946:4;18934:17;;18899:70;:::i;:::-;18985:20;;18515:496;-1:-1:-1;;;;18515:496:1:o;19148:127::-;19209:10;19204:3;19200:20;19197:1;19190:31;19240:4;19237:1;19230:15;19264:4;19261:1;19254:15

ipfs://6bc5839c021d2fd19a55183e3b4f7ecd43cef55d056e52d129fbf9579b94763c