Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at apescan.io on 2025-04-08
*/

// File: @pythnetwork/pyth-sdk-solidity/PythStructs.sol

pragma solidity ^0.8.0;

contract PythStructs {
    // A price with a degree of uncertainty, represented as a price +- a confidence interval.
    //
    // The confidence interval roughly corresponds to the standard error of a normal distribution.
    // Both the price and confidence are stored in a fixed-point numeric representation,
    // `x * (10^expo)`, where `expo` is the exponent.
    //
    // Please refer to the documentation at https://docs.pyth.network/documentation/pythnet-price-feeds/best-practices for how
    // to how this price safely.
    struct Price {
        // Price
        int64 price;
        // Confidence interval around the price
        uint64 conf;
        // Price exponent
        int32 expo;
        // Unix timestamp describing when the price was published
        uint publishTime;
    }

    // PriceFeed represents a current aggregate price from pyth publisher feeds.
    struct PriceFeed {
        // The price ID.
        bytes32 id;
        // Latest available price
        Price price;
        // Latest available exponentially-weighted moving average price
        Price emaPrice;
    }
}

// File: @pythnetwork/pyth-sdk-solidity/IPythEvents.sol


pragma solidity ^0.8.0;

/// @title IPythEvents contains the events that Pyth contract emits.
/// @dev This interface can be used for listening to the updates for off-chain and testing purposes.
interface IPythEvents {
    /// @dev Emitted when the price feed with `id` has received a fresh update.
    /// @param id The Pyth Price Feed ID.
    /// @param publishTime Publish time of the given price update.
    /// @param price Price of the given price update.
    /// @param conf Confidence interval of the given price update.
    event PriceFeedUpdate(
        bytes32 indexed id,
        uint64 publishTime,
        int64 price,
        uint64 conf
    );
}

// File: @pythnetwork/pyth-sdk-solidity/IPyth.sol


pragma solidity ^0.8.0;



/// @title Consume prices from the Pyth Network (https://pyth.network/).
/// @dev Please refer to the guidance at https://docs.pyth.network/documentation/pythnet-price-feeds/best-practices for how to consume prices safely.
/// @author Pyth Data Association
interface IPyth is IPythEvents {
    /// @notice Returns the price of a price feed without any sanity checks.
    /// @dev This function returns the most recent price update in this contract without any recency checks.
    /// This function is unsafe as the returned price update may be arbitrarily far in the past.
    ///
    /// Users of this function should check the `publishTime` in the price to ensure that the returned price is
    /// sufficiently recent for their application. If you are considering using this function, it may be
    /// safer / easier to use `getPriceNoOlderThan`.
    /// @return price - please read the documentation of PythStructs.Price to understand how to use this safely.
    function getPriceUnsafe(
        bytes32 id
    ) external view returns (PythStructs.Price memory price);

    /// @notice Returns the price that is no older than `age` seconds of the current time.
    /// @dev This function is a sanity-checked version of `getPriceUnsafe` which is useful in
    /// applications that require a sufficiently-recent price. Reverts if the price wasn't updated sufficiently
    /// recently.
    /// @return price - please read the documentation of PythStructs.Price to understand how to use this safely.
    function getPriceNoOlderThan(
        bytes32 id,
        uint age
    ) external view returns (PythStructs.Price memory price);

    /// @notice Returns the exponentially-weighted moving average price of a price feed without any sanity checks.
    /// @dev This function returns the same price as `getEmaPrice` in the case where the price is available.
    /// However, if the price is not recent this function returns the latest available price.
    ///
    /// The returned price can be from arbitrarily far in the past; this function makes no guarantees that
    /// the returned price is recent or useful for any particular application.
    ///
    /// Users of this function should check the `publishTime` in the price to ensure that the returned price is
    /// sufficiently recent for their application. If you are considering using this function, it may be
    /// safer / easier to use either `getEmaPrice` or `getEmaPriceNoOlderThan`.
    /// @return price - please read the documentation of PythStructs.Price to understand how to use this safely.
    function getEmaPriceUnsafe(
        bytes32 id
    ) external view returns (PythStructs.Price memory price);

    /// @notice Returns the exponentially-weighted moving average price that is no older than `age` seconds
    /// of the current time.
    /// @dev This function is a sanity-checked version of `getEmaPriceUnsafe` which is useful in
    /// applications that require a sufficiently-recent price. Reverts if the price wasn't updated sufficiently
    /// recently.
    /// @return price - please read the documentation of PythStructs.Price to understand how to use this safely.
    function getEmaPriceNoOlderThan(
        bytes32 id,
        uint age
    ) external view returns (PythStructs.Price memory price);

    /// @notice Update price feeds with given update messages.
    /// This method requires the caller to pay a fee in wei; the required fee can be computed by calling
    /// `getUpdateFee` with the length of the `updateData` array.
    /// Prices will be updated if they are more recent than the current stored prices.
    /// The call will succeed even if the update is not the most recent.
    /// @dev Reverts if the transferred fee is not sufficient or the updateData is invalid.
    /// @param updateData Array of price update data.
    function updatePriceFeeds(bytes[] calldata updateData) external payable;

    /// @notice Wrapper around updatePriceFeeds that rejects fast if a price update is not necessary. A price update is
    /// necessary if the current on-chain publishTime is older than the given publishTime. It relies solely on the
    /// given `publishTimes` for the price feeds and does not read the actual price update publish time within `updateData`.
    ///
    /// This method requires the caller to pay a fee in wei; the required fee can be computed by calling
    /// `getUpdateFee` with the length of the `updateData` array.
    ///
    /// `priceIds` and `publishTimes` are two arrays with the same size that correspond to senders known publishTime
    /// of each priceId when calling this method. If all of price feeds within `priceIds` have updated and have
    /// a newer or equal publish time than the given publish time, it will reject the transaction to save gas.
    /// Otherwise, it calls updatePriceFeeds method to update the prices.
    ///
    /// @dev Reverts if update is not needed or the transferred fee is not sufficient or the updateData is invalid.
    /// @param updateData Array of price update data.
    /// @param priceIds Array of price ids.
    /// @param publishTimes Array of publishTimes. `publishTimes[i]` corresponds to known `publishTime` of `priceIds[i]`
    function updatePriceFeedsIfNecessary(
        bytes[] calldata updateData,
        bytes32[] calldata priceIds,
        uint64[] calldata publishTimes
    ) external payable;

    /// @notice Returns the required fee to update an array of price updates.
    /// @param updateData Array of price update data.
    /// @return feeAmount The required fee in Wei.
    function getUpdateFee(
        bytes[] calldata updateData
    ) external view returns (uint feeAmount);

    /// @notice Parse `updateData` and return price feeds of the given `priceIds` if they are all published
    /// within `minPublishTime` and `maxPublishTime`.
    ///
    /// You can use this method if you want to use a Pyth price at a fixed time and not the most recent price;
    /// otherwise, please consider using `updatePriceFeeds`. This method may store the price updates on-chain, if they
    /// are more recent than the current stored prices.
    ///
    /// This method requires the caller to pay a fee in wei; the required fee can be computed by calling
    /// `getUpdateFee` with the length of the `updateData` array.
    ///
    ///
    /// @dev Reverts if the transferred fee is not sufficient or the updateData is invalid or there is
    /// no update for any of the given `priceIds` within the given time range.
    /// @param updateData Array of price update data.
    /// @param priceIds Array of price ids.
    /// @param minPublishTime minimum acceptable publishTime for the given `priceIds`.
    /// @param maxPublishTime maximum acceptable publishTime for the given `priceIds`.
    /// @return priceFeeds Array of the price feeds corresponding to the given `priceIds` (with the same order).
    function parsePriceFeedUpdates(
        bytes[] calldata updateData,
        bytes32[] calldata priceIds,
        uint64 minPublishTime,
        uint64 maxPublishTime
    ) external payable returns (PythStructs.PriceFeed[] memory priceFeeds);

    /// @notice Similar to `parsePriceFeedUpdates` but ensures the updates returned are
    /// the first updates published in minPublishTime. That is, if there are multiple updates for a given timestamp,
    /// this method will return the first update. This method may store the price updates on-chain, if they
    /// are more recent than the current stored prices.
    ///
    ///
    /// @dev Reverts if the transferred fee is not sufficient or the updateData is invalid or there is
    /// no update for any of the given `priceIds` within the given time range and uniqueness condition.
    /// @param updateData Array of price update data.
    /// @param priceIds Array of price ids.
    /// @param minPublishTime minimum acceptable publishTime for the given `priceIds`.
    /// @param maxPublishTime maximum acceptable publishTime for the given `priceIds`.
    /// @return priceFeeds Array of the price feeds corresponding to the given `priceIds` (with the same order).
    function parsePriceFeedUpdatesUnique(
        bytes[] calldata updateData,
        bytes32[] calldata priceIds,
        uint64 minPublishTime,
        uint64 maxPublishTime
    ) external payable returns (PythStructs.PriceFeed[] memory priceFeeds);
}


// File: contact.sol


pragma solidity ^0.8.20;


// SPDX-License-Identifier: MIT
// File: @openzeppelin/[email protected]/interfaces/draft-IERC6093.sol


// 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/[email protected]/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/[email protected]/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/[email protected]/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/[email protected]/utils/Context.sol


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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// File: @openzeppelin/[email protected]/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);
    }
}

// File: @openzeppelin/[email protected]/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/[email protected]/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/[email protected]/interfaces/IERC165.sol


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

pragma solidity ^0.8.20;


// File: @openzeppelin/[email protected]/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/[email protected]/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/[email protected]/interfaces/IERC721.sol


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

pragma solidity ^0.8.20;


// File: @openzeppelin/[email protected]/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/[email protected]/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/[email protected]/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 tokenId => address) private _owners;

    mapping(address owner => uint256) private _balances;

    mapping(uint256 tokenId => address) private _tokenApprovals;

    mapping(address owner => mapping(address operator => 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/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _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
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

pragma solidity ^0.8.0;

interface AggregatorV3Interface {
  function decimals() external view returns (uint8);

  function description() external view returns (string memory);

  function version() external view returns (uint256);

  function getRoundData(
    uint80 _roundId
  ) external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);

  function latestRoundData()
    external
    view
    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}

interface mainContract {
    function mint(address to, string memory uri) external returns (uint256);
    function safeMint(address to, string memory uri) external;
}
contract GOSUONAPE_SALE is Ownable, ReentrancyGuard {
    uint256 private _nextTokenId;

    mainContract public mainContractInstance;
    
    uint256 private _tokenPrice = 13000000000000000000;
    uint256 private _totalSupply = 1500;
    uint256 private _totalMinted = 1;
    
    uint256[] public _wlPrice;
    mapping(address => uint256) public nonces;
    bool public normalMintStarted = false;
    
    bool public isLaunched = false;
    
    string public uri = "https://cbmdsup8tf.execute-api.eu-central-1.amazonaws.com/prod/metadata/67f162e8cb97f5de2ba35945/";
    
    
    
    
    uint256 public platformFeeAmount = 0 ether;

    uint256 public platformFee = 10; // $1 per mint base of 10
    
    IPyth pyth = IPyth(0x2880aB155794e7179c9eE2e38200202908C17B43);
    
    address private signerAddress = 0x9aC26D5af386f5950D3D94476aFB4060325c6976;
    address private aiowAddress = 0x9aC26D5af386f5950D3D94476aFB4060325c6976;

    
    constructor(address _initialOwner) Ownable(_initialOwner) {
        
        
        
        _wlPrice.push(13000000000000000000);
        
        _wlPrice.push(15000000000000000000);
        
        
    }

    function checkRequirement(uint256 amount) internal view returns (bool) {
        return _totalSupply >= _totalMinted + (amount - 1) && isLaunched   && normalMintStarted;
    }
    
    function safeMint(address to) public payable onlyOwner {
        require(_totalSupply >= _totalMinted, "All token minted");
        require(msg.value >= getRealPrice(), "invalid price recived");
        platformFeeAmount += msg.value;
        
        mainContractInstance.safeMint(to, string(abi.encodePacked(uri,uintToString(_totalMinted), ".json")));
        
        _totalMinted = _totalMinted + 1;  
    }

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

    
    function mint(uint256 amount)
    public
    payable
    {
        require(msg.value >= getTokenPrice(amount), "Price mismatch");
        require(checkRequirement(amount), "Either batch is full or all token are mined or contract is not launched yet");
        
        require(20 >= amount, "You can only max 20 mint at a time.");

        for (uint256 i = 0; i < amount; i++) {
        
        
        
        mainContractInstance.mint(msg.sender, string(abi.encodePacked(uri,uintToString(_totalMinted), ".json")));
        
        platformFeeAmount += getRealPrice();
        _totalMinted = _totalMinted + 1;
        
        }
        
    }

    function getTokenPrice(uint256 amount) view public returns (uint256) {
        return amount*(_tokenPrice + getRealPrice());
    }
    

    
    function verifyAddressSigner(bytes memory signature) public view returns (bool) {
        bytes32 messageHash = keccak256(abi.encodePacked(msg.sender));
        bytes32 ethSignedMessageHash = toEthSignedMessageHash(messageHash);
        return recoverSigner(ethSignedMessageHash, signature) == signerAddress;
    }

    function toEthSignedMessageHash(bytes32 _messageHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _messageHash));
    }
    
    function recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature) internal pure returns (address) {
        require(_signature.length == 65, "Invalid signature length");

        bytes32 r;
        bytes32 s;
        uint8 v;

        // Split the signature into r, s, and v variables
        assembly {
            r := mload(add(_signature, 32))
            s := mload(add(_signature, 64))
            v := byte(0, mload(add(_signature, 96)))
        }

        // Adjust the `v` value if necessary
        if (v < 27) {
            v += 27;
        }

        require(v == 27 || v == 28, "Invalid signature 'v' value");

        // Perform ecrecover and return the signer address
        return ecrecover(_ethSignedMessageHash, v, r, s);
    }

    function startNormalMint() external onlyOwner {
        normalMintStarted = true;
    }

    function checkWLRequirement(uint256 amount) internal view returns (bool) {
        return _totalSupply >= _totalMinted + (amount - 1) && isLaunched && !normalMintStarted ;
    }

    function whitelistMint(bytes[] memory signature, uint256 rank, uint256 nouce, uint256 amount)
    public
    payable
    {
        require(msg.value >= getWhiteListPrice(rank , amount), "Price mismatch");
        require(checkWLRequirement(amount), "Either batch is full or all token are minted or contract is not launched yet");
        require(verifyAddressSigner(signature[0]), "Incorrect Signature");
        
        require(20 >= amount, "You can only mint 20 at a time.");
        for (uint256 i = 0; i < amount; i++) {
        
        
        mainContractInstance.mint(msg.sender, string(abi.encodePacked(uri,uintToString(_totalMinted), ".json")));
        platformFeeAmount += getRealPrice();
        
        _totalMinted = _totalMinted + 1;
        
        }
        
    }

    function setwlPrice(uint256 wlPrice, uint256 rank) public onlyOwner {
        _wlPrice[rank] = wlPrice;
    }

    function addwlPrice(uint256 wlPrice) public onlyOwner {
        _wlPrice.push(wlPrice);
    }

    function getWhiteListPrice(uint256 rank, uint256 amount) view public returns (uint256) {
        
        return amount* (_wlPrice[rank] + getRealPrice());
    }
    
    

    function launch(address _nftAddress) public onlyOwner {
        isLaunched = true;
        mainContractInstance = mainContract(_nftAddress);
        
    }

    
    function setTokenUriSaleContract(string memory _uri) public onlyOwner {
        uri = _uri;
    }
    


    function setTokenPrice(uint256 tokenPrice) public onlyOwner {
        _tokenPrice = tokenPrice;
    }

    function setTotalSupply(uint256 totalSupply) public onlyOwner {
        _totalSupply = totalSupply;
    }

    function setAiowAddress(address _address) public onlyServer {
        aiowAddress = _address;
    }

    function setSignerAddress(address _signerAddress) public onlyServer {
        signerAddress = _signerAddress;
    }



    
    



    function setNFTContract(address _nftAddress) public onlyOwner {
        mainContractInstance = mainContract(_nftAddress);
    }
    
    
    function getRealPrice() public view returns (uint256) {
        PythStructs.Price memory priceData = pyth.getPriceUnsafe(0x15add95022ae13563a11992e727c91bdb6b55bc183d9d747436c80a483d8c864);
        return (10**26)/uint64(priceData.price);
    }
    
    modifier onlyServer {
        require(msg.sender == aiowAddress);
        _;
    }

    function withdraw() public onlyOwner nonReentrant {
        (bool hs, ) = payable(aiowAddress).call{value: platformFeeAmount}('');
        require(hs);
        platformFeeAmount = 0 ether;
        
        
        (bool os, ) = payable(owner()).call{value: address(this).balance}('');
        require(os);
        
    }

    function withdrawPlatformFee() public onlyServer nonReentrant {
        (bool hs, ) = payable(aiowAddress).call{value: platformFeeAmount}('');
        require(hs);
        platformFeeAmount = 0 ether;
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_initialOwner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"_wlPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"wlPrice","type":"uint256"}],"name":"addwlPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getRealPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"getTokenPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"rank","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"getWhiteListPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isLaunched","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_nftAddress","type":"address"}],"name":"launch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mainContractInstance","outputs":[{"internalType":"contract mainContract","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"normalMintStarted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"platformFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"platformFeeAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"safeMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"setAiowAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_nftAddress","type":"address"}],"name":"setNFTContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_signerAddress","type":"address"}],"name":"setSignerAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenPrice","type":"uint256"}],"name":"setTokenPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uri","type":"string"}],"name":"setTokenUriSaleContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"totalSupply","type":"uint256"}],"name":"setTotalSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"wlPrice","type":"uint256"},{"internalType":"uint256","name":"rank","type":"uint256"}],"name":"setwlPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startNormalMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"verifyAddressSigner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"signature","type":"bytes[]"},{"internalType":"uint256","name":"rank","type":"uint256"},{"internalType":"uint256","name":"nouce","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawPlatformFee","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000020481b842acaefc26732602e66abf1773acf2438

-----Decoded View---------------
Arg [0] : _initialOwner (address): 0x20481B842acAEFC26732602e66ABf1773AcF2438

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000020481b842acaefc26732602e66abf1773acf2438

73477:7843:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80121:117;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;79314:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77994:89;;;;;;;;;;;;;:::i;:::-;;79671:99;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;81105:210;;;;;;;;;;;;;:::i;:::-;;79498:159;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;74144:31;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73900:30;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;76677:318;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;80767:330;;;;;;;;;;;;;:::i;:::-;;74872:419;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;79211:95;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;73770:25;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;80415:247;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;79786:103;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40831;;;;;;;;;;;;;:::i;:::-;;73850:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73802:41;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;79092:111;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;80012:101;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40156:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75849:668;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;80268:129;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;78278:806;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;74093:42;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;76525:132;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73573:40;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73943:119;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41089:220;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;79897:107;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;80121:117;80727:11;;;;;;;;;;;80713:25;;:10;:25;;;80705:34;;;;;;80216:14:::1;80200:13;;:30;;;;;;;;;;;;;;;;;;80121:117:::0;:::o;79314:164::-;79392:7;79455:14;:12;:14::i;:::-;79438:8;79447:4;79438:14;;;;;;;;:::i;:::-;;;;;;;;;;:31;;;;:::i;:::-;79429:6;:41;;;;:::i;:::-;79422:48;;79314:164;;;;:::o;77994:89::-;40042:13;:11;:13::i;:::-;78071:4:::1;78051:17;;:24;;;;;;;;;;;;;;;;;;77994:89::o:0;79671:99::-;40042:13;:11;:13::i;:::-;79758:4:::1;79752:3;:10;;;;;;:::i;:::-;;79671:99:::0;:::o;81105:210::-;80727:11;;;;;;;;;;;80713:25;;:10;:25;;;80705:34;;;;;;71831:21:::1;:19;:21::i;:::-;81179:7:::2;81200:11;;;;;;;;;;;81192:25;;81225:17;;81192:55;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;81178:69;;;81266:2;81258:11;;;::::0;::::2;;81300:7;81280:17;:27;;;;81167:148;71875:20:::1;:18;:20::i;:::-;81105:210::o:0;79498:159::-;40042:13;:11;:13::i;:::-;79576:4:::1;79563:10;;:17;;;;;;;;;;;;;;;;;;79627:11;79591:20;;:48;;;;;;;;;;;;;;;;;;79498:159:::0;:::o;74144:31::-;;;;:::o;73900:30::-;;;;;;;;;;;;;:::o;76677:318::-;76751:4;76768:19;76817:10;76800:28;;;;;;;;:::i;:::-;;;;;;;;;;;;;76790:39;;;;;;76768:61;;76840:28;76871:35;76894:11;76871:22;:35::i;:::-;76840:66;;76974:13;;;;;;;;;;;76924:63;;:46;76938:20;76960:9;76924:13;:46::i;:::-;:63;;;76917:70;;;;76677:318;;;:::o;80767:330::-;40042:13;:11;:13::i;:::-;71831:21:::1;:19;:21::i;:::-;80829:7:::2;80850:11;;;;;;;;;;;80842:25;;80875:17;;80842:55;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80828:69;;;80916:2;80908:11;;;::::0;::::2;;80950:7;80930:17;:27;;;;80989:7;81010;:5;:7::i;:::-;81002:21;;81031;81002:55;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80988:69;;;81076:2;81068:11;;;::::0;::::2;;80817:280;;71875:20:::1;:18;:20::i;:::-;80767:330::o:0;74872:419::-;40042:13;:11;:13::i;:::-;74962:12:::1;;74946;;:28;;74938:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;75027:14;:12;:14::i;:::-;75014:9;:27;;75006:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;75099:9;75078:17;;:30;;;;;;;:::i;:::-;;;;;;;;75129:20;;;;;;;;;;;:29;;;75159:2;75187:3;75191:26;75204:12;;75191;:26::i;:::-;75170:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;75129:100;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;75280:1;75265:12;;:16;;;;:::i;:::-;75250:12;:31;;;;74872:419:::0;:::o;79211:95::-;40042:13;:11;:13::i;:::-;79276:8:::1;79290:7;79276:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79211:95:::0;:::o;73770:25::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;80415:247::-;80460:7;80480:34;80517:4;;;;;;;;;;;:19;;;80537:66;80517:87;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;80480:124;;80638:9;:15;;;80622:32;;80623:6;80622:32;;;;:::i;:::-;80615:39;;;;;80415:247;:::o;79786:103::-;40042:13;:11;:13::i;:::-;79871:10:::1;79857:11;:24;;;;79786:103:::0;:::o;40831:::-;40042:13;:11;:13::i;:::-;40896:30:::1;40923:1;40896:18;:30::i;:::-;40831:103::o:0;73850:37::-;;;;;;;;;;;;;:::o;73802:41::-;;;;;;;;;;;;;;;;;:::o;79092:111::-;40042:13;:11;:13::i;:::-;79188:7:::1;79171:8;79180:4;79171:14;;;;;;;;:::i;:::-;;;;;;;;;:24;;;;79092:111:::0;;:::o;80012:101::-;80727:11;;;;;;;;;;;80713:25;;:10;:25;;;80705:34;;;;;;80097:8:::1;80083:11;;:22;;;;;;;;;;;;;;;;;;80012:101:::0;:::o;40156:87::-;40202:7;40229:6;;;;;;;;;;;40222:13;;40156:87;:::o;75849:668::-;75941:21;75955:6;75941:13;:21::i;:::-;75928:9;:34;;75920:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;76000:24;76017:6;76000:16;:24::i;:::-;75992:112;;;;;;;;;;;;:::i;:::-;;;;;;;;;76139:6;76133:2;:12;;76125:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;76203:9;76198:302;76222:6;76218:1;:10;76198:302;;;76276:20;;;;;;;;;;;:25;;;76302:10;76338:3;76342:26;76355:12;;76342;:26::i;:::-;76321:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;76276:104;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;76422:14;:12;:14::i;:::-;76401:17;;:35;;;;;;;:::i;:::-;;;;;;;;76477:1;76462:12;;:16;;;;:::i;:::-;76447:12;:31;;;;76230:3;;;;;;;76198:302;;;;75849:668;:::o;80268:129::-;40042:13;:11;:13::i;:::-;80377:11:::1;80341:20;;:48;;;;;;;;;;;;;;;;;;80268:129:::0;:::o;78278:806::-;78434:32;78452:4;78459:6;78434:17;:32::i;:::-;78421:9;:45;;78413:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;78504:26;78523:6;78504:18;:26::i;:::-;78496:115;;;;;;;;;;;;:::i;:::-;;;;;;;;;78630:33;78650:9;78660:1;78650:12;;;;;;;;:::i;:::-;;;;;;;;78630:19;:33::i;:::-;78622:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;78722:6;78716:2;:12;;78708:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;78780:9;78775:292;78799:6;78795:1;:10;78775:292;;;78843:20;;;;;;;;;;;:25;;;78869:10;78905:3;78909:26;78922:12;;78909;:26::i;:::-;78888:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;78843:104;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;78979:14;:12;:14::i;:::-;78958:17;;:35;;;;;;;:::i;:::-;;;;;;;;79044:1;79029:12;;:16;;;;:::i;:::-;79014:12;:31;;;;78807:3;;;;;;;78775:292;;;;78278:806;;;;:::o;74093:42::-;;;;:::o;76525:132::-;76585:7;76634:14;:12;:14::i;:::-;76620:11;;:28;;;;:::i;:::-;76612:6;:37;;;;:::i;:::-;76605:44;;76525:132;;;:::o;73573:40::-;;;;;;;;;;;;;:::o;73943:119::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;41089:220::-;40042:13;:11;:13::i;:::-;41194:1:::1;41174:22;;:8;:22;;::::0;41170:93:::1;;41248:1;41220:31;;;;;;;;;;;:::i;:::-;;;;;;;;41170:93;41273:28;41292:8;41273:18;:28::i;:::-;41089:220:::0;:::o;79897:107::-;40042:13;:11;:13::i;:::-;79985:11:::1;79970:12;:26;;;;79897:107:::0;:::o;40321:166::-;40392:12;:10;:12::i;:::-;40381:23;;:7;:5;:7::i;:::-;:23;;;40377:103;;40455:12;:10;:12::i;:::-;40428:40;;;;;;;;;;;:::i;:::-;;;;;;;;40377:103;40321:166::o;71911:293::-;71313:1;72045:7;;:19;72037:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;71313:1;72178:7;:18;;;;71911:293::o;72212:213::-;71269:1;72395:7;:22;;;;72212:213::o;77003:189::-;77080:7;77170:12;77117:66;;;;;;;;:::i;:::-;;;;;;;;;;;;;77107:77;;;;;;77100:84;;77003:189;;;:::o;77204:782::-;77306:7;77355:2;77334:10;:17;:23;77326:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;77399:9;77419;77439:7;77569:2;77557:10;77553:19;77547:26;77542:31;;77614:2;77602:10;77598:19;77592:26;77587:31;;77667:2;77655:10;77651:19;77645:26;77642:1;77637:35;77632:40;;77749:2;77745:1;:6;;;77741:46;;;77773:2;77768:7;;;;;:::i;:::-;;;77741:46;77812:2;77807:1;:7;;;:18;;;;77823:2;77818:1;:7;;;77807:18;77799:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;77937:41;77947:21;77970:1;77973;77976;77937:41;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77930:48;;;;;77204:782;;;;:::o;75299:536::-;75359:13;75398:1;75389:5;:10;75385:53;;75416:10;;;;;;;;;;;;;;;;;;;;;75385:53;75448:12;75463:5;75448:20;;75479:14;75504:78;75519:1;75511:4;:9;75504:78;;75537:8;;;;;:::i;:::-;;;;75568:2;75560:10;;;;;:::i;:::-;;;75504:78;;;75592:19;75624:6;75614:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75592:39;;75642:154;75658:1;75649:5;:10;75642:154;;75686:1;75676:11;;;;;:::i;:::-;;;75753:2;75745:5;:10;;;;:::i;:::-;75732:2;:24;;;;:::i;:::-;75719:39;;75702:6;75709;75702:14;;;;;;;;:::i;:::-;;;;;:56;;;;;;;;;;;75782:2;75773:11;;;;;:::i;:::-;;;75642:154;;;75820:6;75806:21;;;;;75299:536;;;;:::o;41469:191::-;41543:16;41562:6;;;;;;;;;;;41543:25;;41588:8;41579:6;;:17;;;;;;;;;;;;;;;;;;41643:8;41612:40;;41633:8;41612:40;;;;;;;;;;;;41532:128;41469:191;:::o;74683:177::-;74748:4;74813:1;74804:6;:10;;;;:::i;:::-;74788:12;;:27;;;;:::i;:::-;74772:12;;:43;;:57;;;;;74819:10;;;;;;;;;;;74772:57;:80;;;;;74835:17;;;;;;;;;;;74772:80;74765:87;;74683:177;;;:::o;78091:179::-;78158:4;78223:1;78214:6;:10;;;;:::i;:::-;78198:12;;:27;;;;:::i;:::-;78182:12;;:43;;:57;;;;;78229:10;;;;;;;;;;;78182:57;:79;;;;;78244:17;;;;;;;;;;;78243:18;78182:79;78175:86;;78091:179;;;:::o;38159:98::-;38212:7;38239:10;38232:17;;38159:98;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:329::-;900:6;949:2;937:9;928:7;924:23;920:32;917:119;;;955:79;;:::i;:::-;917:119;1075:1;1100:53;1145:7;1136:6;1125:9;1121:22;1100:53;:::i;:::-;1090:63;;1046:117;841:329;;;;:::o;1176:77::-;1213:7;1242:5;1231:16;;1176:77;;;:::o;1259:122::-;1332:24;1350:5;1332:24;:::i;:::-;1325:5;1322:35;1312:63;;1371:1;1368;1361:12;1312:63;1259:122;:::o;1387:139::-;1433:5;1471:6;1458:20;1449:29;;1487:33;1514:5;1487:33;:::i;:::-;1387:139;;;;:::o;1532:474::-;1600:6;1608;1657:2;1645:9;1636:7;1632:23;1628:32;1625:119;;;1663:79;;:::i;:::-;1625:119;1783:1;1808:53;1853:7;1844:6;1833:9;1829:22;1808:53;:::i;:::-;1798:63;;1754:117;1910:2;1936:53;1981:7;1972:6;1961:9;1957:22;1936:53;:::i;:::-;1926:63;;1881:118;1532:474;;;;;:::o;2012:118::-;2099:24;2117:5;2099:24;:::i;:::-;2094:3;2087:37;2012:118;;:::o;2136:222::-;2229:4;2267:2;2256:9;2252:18;2244:26;;2280:71;2348:1;2337:9;2333:17;2324:6;2280:71;:::i;:::-;2136:222;;;;:::o;2364:117::-;2473:1;2470;2463:12;2487:117;2596:1;2593;2586:12;2610:102;2651:6;2702:2;2698:7;2693:2;2686:5;2682:14;2678:28;2668:38;;2610:102;;;:::o;2718:180::-;2766:77;2763:1;2756:88;2863:4;2860:1;2853:15;2887:4;2884:1;2877:15;2904:281;2987:27;3009:4;2987:27;:::i;:::-;2979:6;2975:40;3117:6;3105:10;3102:22;3081:18;3069:10;3066:34;3063:62;3060:88;;;3128:18;;:::i;:::-;3060:88;3168:10;3164:2;3157:22;2947:238;2904:281;;:::o;3191:129::-;3225:6;3252:20;;:::i;:::-;3242:30;;3281:33;3309:4;3301:6;3281:33;:::i;:::-;3191:129;;;:::o;3326:308::-;3388:4;3478:18;3470:6;3467:30;3464:56;;;3500:18;;:::i;:::-;3464:56;3538:29;3560:6;3538:29;:::i;:::-;3530:37;;3622:4;3616;3612:15;3604:23;;3326:308;;;:::o;3640:146::-;3737:6;3732:3;3727;3714:30;3778:1;3769:6;3764:3;3760:16;3753:27;3640:146;;;:::o;3792:425::-;3870:5;3895:66;3911:49;3953:6;3911:49;:::i;:::-;3895:66;:::i;:::-;3886:75;;3984:6;3977:5;3970:21;4022:4;4015:5;4011:16;4060:3;4051:6;4046:3;4042:16;4039:25;4036:112;;;4067:79;;:::i;:::-;4036:112;4157:54;4204:6;4199:3;4194;4157:54;:::i;:::-;3876:341;3792:425;;;;;:::o;4237:340::-;4293:5;4342:3;4335:4;4327:6;4323:17;4319:27;4309:122;;4350:79;;:::i;:::-;4309:122;4467:6;4454:20;4492:79;4567:3;4559:6;4552:4;4544:6;4540:17;4492:79;:::i;:::-;4483:88;;4299:278;4237:340;;;;:::o;4583:509::-;4652:6;4701:2;4689:9;4680:7;4676:23;4672:32;4669:119;;;4707:79;;:::i;:::-;4669:119;4855:1;4844:9;4840:17;4827:31;4885:18;4877:6;4874:30;4871:117;;;4907:79;;:::i;:::-;4871:117;5012:63;5067:7;5058:6;5047:9;5043:22;5012:63;:::i;:::-;5002:73;;4798:287;4583:509;;;;:::o;5098:90::-;5132:7;5175:5;5168:13;5161:21;5150:32;;5098:90;;;:::o;5194:109::-;5275:21;5290:5;5275:21;:::i;:::-;5270:3;5263:34;5194:109;;:::o;5309:210::-;5396:4;5434:2;5423:9;5419:18;5411:26;;5447:65;5509:1;5498:9;5494:17;5485:6;5447:65;:::i;:::-;5309:210;;;;:::o;5525:307::-;5586:4;5676:18;5668:6;5665:30;5662:56;;;5698:18;;:::i;:::-;5662:56;5736:29;5758:6;5736:29;:::i;:::-;5728:37;;5820:4;5814;5810:15;5802:23;;5525:307;;;:::o;5838:423::-;5915:5;5940:65;5956:48;5997:6;5956:48;:::i;:::-;5940:65;:::i;:::-;5931:74;;6028:6;6021:5;6014:21;6066:4;6059:5;6055:16;6104:3;6095:6;6090:3;6086:16;6083:25;6080:112;;;6111:79;;:::i;:::-;6080:112;6201:54;6248:6;6243:3;6238;6201:54;:::i;:::-;5921:340;5838:423;;;;;:::o;6280:338::-;6335:5;6384:3;6377:4;6369:6;6365:17;6361:27;6351:122;;6392:79;;:::i;:::-;6351:122;6509:6;6496:20;6534:78;6608:3;6600:6;6593:4;6585:6;6581:17;6534:78;:::i;:::-;6525:87;;6341:277;6280:338;;;;:::o;6624:507::-;6692:6;6741:2;6729:9;6720:7;6716:23;6712:32;6709:119;;;6747:79;;:::i;:::-;6709:119;6895:1;6884:9;6880:17;6867:31;6925:18;6917:6;6914:30;6911:117;;;6947:79;;:::i;:::-;6911:117;7052:62;7106:7;7097:6;7086:9;7082:22;7052:62;:::i;:::-;7042:72;;6838:286;6624:507;;;;:::o;7137:329::-;7196:6;7245:2;7233:9;7224:7;7220:23;7216:32;7213:119;;;7251:79;;:::i;:::-;7213:119;7371:1;7396:53;7441:7;7432:6;7421:9;7417:22;7396:53;:::i;:::-;7386:63;;7342:117;7137:329;;;;:::o;7472:118::-;7559:24;7577:5;7559:24;:::i;:::-;7554:3;7547:37;7472:118;;:::o;7596:222::-;7689:4;7727:2;7716:9;7712:18;7704:26;;7740:71;7808:1;7797:9;7793:17;7784:6;7740:71;:::i;:::-;7596:222;;;;:::o;7824:320::-;7910:4;8000:18;7992:6;7989:30;7986:56;;;8022:18;;:::i;:::-;7986:56;8072:4;8064:6;8060:17;8052:25;;8132:4;8126;8122:15;8114:23;;7824:320;;;:::o;8150:117::-;8259:1;8256;8249:12;8288:942;8393:5;8418:90;8434:73;8500:6;8434:73;:::i;:::-;8418:90;:::i;:::-;8409:99;;8528:5;8557:6;8550:5;8543:21;8591:4;8584:5;8580:16;8573:23;;8644:4;8636:6;8632:17;8624:6;8620:30;8673:3;8665:6;8662:15;8659:122;;;8692:79;;:::i;:::-;8659:122;8807:6;8790:434;8824:6;8819:3;8816:15;8790:434;;;8913:3;8900:17;8949:18;8936:11;8933:35;8930:122;;;8971:79;;:::i;:::-;8930:122;9095:11;9087:6;9083:24;9133:46;9175:3;9163:10;9133:46;:::i;:::-;9128:3;9121:59;9209:4;9204:3;9200:14;9193:21;;8866:358;;8850:4;8845:3;8841:14;8834:21;;8790:434;;;8794:21;8399:831;;8288:942;;;;;:::o;9251:388::-;9331:5;9380:3;9373:4;9365:6;9361:17;9357:27;9347:122;;9388:79;;:::i;:::-;9347:122;9505:6;9492:20;9530:103;9629:3;9621:6;9614:4;9606:6;9602:17;9530:103;:::i;:::-;9521:112;;9337:302;9251:388;;;;:::o;9645:993::-;9765:6;9773;9781;9789;9838:3;9826:9;9817:7;9813:23;9809:33;9806:120;;;9845:79;;:::i;:::-;9806:120;9993:1;9982:9;9978:17;9965:31;10023:18;10015:6;10012:30;10009:117;;;10045:79;;:::i;:::-;10009:117;10150:87;10229:7;10220:6;10209:9;10205:22;10150:87;:::i;:::-;10140:97;;9936:311;10286:2;10312:53;10357:7;10348:6;10337:9;10333:22;10312:53;:::i;:::-;10302:63;;10257:118;10414:2;10440:53;10485:7;10476:6;10465:9;10461:22;10440:53;:::i;:::-;10430:63;;10385:118;10542:2;10568:53;10613:7;10604:6;10593:9;10589:22;10568:53;:::i;:::-;10558:63;;10513:118;9645:993;;;;;;;:::o;10644:60::-;10672:3;10693:5;10686:12;;10644:60;;;:::o;10710:142::-;10760:9;10793:53;10811:34;10820:24;10838:5;10820:24;:::i;:::-;10811:34;:::i;:::-;10793:53;:::i;:::-;10780:66;;10710:142;;;:::o;10858:126::-;10908:9;10941:37;10972:5;10941:37;:::i;:::-;10928:50;;10858:126;;;:::o;10990:147::-;11061:9;11094:37;11125:5;11094:37;:::i;:::-;11081:50;;10990:147;;;:::o;11143:173::-;11251:58;11303:5;11251:58;:::i;:::-;11246:3;11239:71;11143:173;;:::o;11322:264::-;11436:4;11474:2;11463:9;11459:18;11451:26;;11487:92;11576:1;11565:9;11561:17;11552:6;11487:92;:::i;:::-;11322:264;;;;:::o;11592:99::-;11644:6;11678:5;11672:12;11662:22;;11592:99;;;:::o;11697:169::-;11781:11;11815:6;11810:3;11803:19;11855:4;11850:3;11846:14;11831:29;;11697:169;;;;:::o;11872:246::-;11953:1;11963:113;11977:6;11974:1;11971:13;11963:113;;;12062:1;12057:3;12053:11;12047:18;12043:1;12038:3;12034:11;12027:39;11999:2;11996:1;11992:10;11987:15;;11963:113;;;12110:1;12101:6;12096:3;12092:16;12085:27;11934:184;11872:246;;;:::o;12124:377::-;12212:3;12240:39;12273:5;12240:39;:::i;:::-;12295:71;12359:6;12354:3;12295:71;:::i;:::-;12288:78;;12375:65;12433:6;12428:3;12421:4;12414:5;12410:16;12375:65;:::i;:::-;12465:29;12487:6;12465:29;:::i;:::-;12460:3;12456:39;12449:46;;12216:285;12124:377;;;;:::o;12507:313::-;12620:4;12658:2;12647:9;12643:18;12635:26;;12707:9;12701:4;12697:20;12693:1;12682:9;12678:17;12671:47;12735:78;12808:4;12799:6;12735:78;:::i;:::-;12727:86;;12507:313;;;;:::o;12826:180::-;12874:77;12871:1;12864:88;12971:4;12968:1;12961:15;12995:4;12992:1;12985:15;13012:180;13060:77;13057:1;13050:88;13157:4;13154:1;13147:15;13181:4;13178:1;13171:15;13198:191;13238:3;13257:20;13275:1;13257:20;:::i;:::-;13252:25;;13291:20;13309:1;13291:20;:::i;:::-;13286:25;;13334:1;13331;13327:9;13320:16;;13355:3;13352:1;13349:10;13346:36;;;13362:18;;:::i;:::-;13346:36;13198:191;;;;:::o;13395:410::-;13435:7;13458:20;13476:1;13458:20;:::i;:::-;13453:25;;13492:20;13510:1;13492:20;:::i;:::-;13487:25;;13547:1;13544;13540:9;13569:30;13587:11;13569:30;:::i;:::-;13558:41;;13748:1;13739:7;13735:15;13732:1;13729:22;13709:1;13702:9;13682:83;13659:139;;13778:18;;:::i;:::-;13659:139;13443:362;13395:410;;;;:::o;13811:180::-;13859:77;13856:1;13849:88;13956:4;13953:1;13946:15;13980:4;13977:1;13970:15;13997:320;14041:6;14078:1;14072:4;14068:12;14058:22;;14125:1;14119:4;14115:12;14146:18;14136:81;;14202:4;14194:6;14190:17;14180:27;;14136:81;14264:2;14256:6;14253:14;14233:18;14230:38;14227:84;;14283:18;;:::i;:::-;14227:84;14048:269;13997:320;;;:::o;14323:141::-;14372:4;14395:3;14387:11;;14418:3;14415:1;14408:14;14452:4;14449:1;14439:18;14431:26;;14323:141;;;:::o;14470:93::-;14507:6;14554:2;14549;14542:5;14538:14;14534:23;14524:33;;14470:93;;;:::o;14569:107::-;14613:8;14663:5;14657:4;14653:16;14632:37;;14569:107;;;;:::o;14682:393::-;14751:6;14801:1;14789:10;14785:18;14824:97;14854:66;14843:9;14824:97;:::i;:::-;14942:39;14972:8;14961:9;14942:39;:::i;:::-;14930:51;;15014:4;15010:9;15003:5;14999:21;14990:30;;15063:4;15053:8;15049:19;15042:5;15039:30;15029:40;;14758:317;;14682:393;;;;;:::o;15081:142::-;15131:9;15164:53;15182:34;15191:24;15209:5;15191:24;:::i;:::-;15182:34;:::i;:::-;15164:53;:::i;:::-;15151:66;;15081:142;;;:::o;15229:75::-;15272:3;15293:5;15286:12;;15229:75;;;:::o;15310:269::-;15420:39;15451:7;15420:39;:::i;:::-;15481:91;15530:41;15554:16;15530:41;:::i;:::-;15522:6;15515:4;15509:11;15481:91;:::i;:::-;15475:4;15468:105;15386:193;15310:269;;;:::o;15585:73::-;15630:3;15585:73;:::o;15664:189::-;15741:32;;:::i;:::-;15782:65;15840:6;15832;15826:4;15782:65;:::i;:::-;15717:136;15664:189;;:::o;15859:186::-;15919:120;15936:3;15929:5;15926:14;15919:120;;;15990:39;16027:1;16020:5;15990:39;:::i;:::-;15963:1;15956:5;15952:13;15943:22;;15919:120;;;15859:186;;:::o;16051:543::-;16152:2;16147:3;16144:11;16141:446;;;16186:38;16218:5;16186:38;:::i;:::-;16270:29;16288:10;16270:29;:::i;:::-;16260:8;16256:44;16453:2;16441:10;16438:18;16435:49;;;16474:8;16459:23;;16435:49;16497:80;16553:22;16571:3;16553:22;:::i;:::-;16543:8;16539:37;16526:11;16497:80;:::i;:::-;16156:431;;16141:446;16051:543;;;:::o;16600:117::-;16654:8;16704:5;16698:4;16694:16;16673:37;;16600:117;;;;:::o;16723:169::-;16767:6;16800:51;16848:1;16844:6;16836:5;16833:1;16829:13;16800:51;:::i;:::-;16796:56;16881:4;16875;16871:15;16861:25;;16774:118;16723:169;;;;:::o;16897:295::-;16973:4;17119:29;17144:3;17138:4;17119:29;:::i;:::-;17111:37;;17181:3;17178:1;17174:11;17168:4;17165:21;17157:29;;16897:295;;;;:::o;17197:1395::-;17314:37;17347:3;17314:37;:::i;:::-;17416:18;17408:6;17405:30;17402:56;;;17438:18;;:::i;:::-;17402:56;17482:38;17514:4;17508:11;17482:38;:::i;:::-;17567:67;17627:6;17619;17613:4;17567:67;:::i;:::-;17661:1;17685:4;17672:17;;17717:2;17709:6;17706:14;17734:1;17729:618;;;;18391:1;18408:6;18405:77;;;18457:9;18452:3;18448:19;18442:26;18433:35;;18405:77;18508:67;18568:6;18561:5;18508:67;:::i;:::-;18502:4;18495:81;18364:222;17699:887;;17729:618;17781:4;17777:9;17769:6;17765:22;17815:37;17847:4;17815:37;:::i;:::-;17874:1;17888:208;17902:7;17899:1;17896:14;17888:208;;;17981:9;17976:3;17972:19;17966:26;17958:6;17951:42;18032:1;18024:6;18020:14;18010:24;;18079:2;18068:9;18064:18;18051:31;;17925:4;17922:1;17918:12;17913:17;;17888:208;;;18124:6;18115:7;18112:19;18109:179;;;18182:9;18177:3;18173:19;18167:26;18225:48;18267:4;18259:6;18255:17;18244:9;18225:48;:::i;:::-;18217:6;18210:64;18132:156;18109:179;18334:1;18330;18322:6;18318:14;18314:22;18308:4;18301:36;17736:611;;;17699:887;;17289:1303;;;17197:1395;;:::o;18598:147::-;18699:11;18736:3;18721:18;;18598:147;;;;:::o;18751:114::-;;:::o;18871:398::-;19030:3;19051:83;19132:1;19127:3;19051:83;:::i;:::-;19044:90;;19143:93;19232:3;19143:93;:::i;:::-;19261:1;19256:3;19252:11;19245:18;;18871:398;;;:::o;19275:379::-;19459:3;19481:147;19624:3;19481:147;:::i;:::-;19474:154;;19645:3;19638:10;;19275:379;;;:::o;19660:94::-;19693:8;19741:5;19737:2;19733:14;19712:35;;19660:94;;;:::o;19760:::-;19799:7;19828:20;19842:5;19828:20;:::i;:::-;19817:31;;19760:94;;;:::o;19860:100::-;19899:7;19928:26;19948:5;19928:26;:::i;:::-;19917:37;;19860:100;;;:::o;19966:157::-;20071:45;20091:24;20109:5;20091:24;:::i;:::-;20071:45;:::i;:::-;20066:3;20059:58;19966:157;;:::o;20129:256::-;20241:3;20256:75;20327:3;20318:6;20256:75;:::i;:::-;20356:2;20351:3;20347:12;20340:19;;20376:3;20369:10;;20129:256;;;;:::o;20391:166::-;20531:18;20527:1;20519:6;20515:14;20508:42;20391:166;:::o;20563:366::-;20705:3;20726:67;20790:2;20785:3;20726:67;:::i;:::-;20719:74;;20802:93;20891:3;20802:93;:::i;:::-;20920:2;20915:3;20911:12;20904:19;;20563:366;;;:::o;20935:419::-;21101:4;21139:2;21128:9;21124:18;21116:26;;21188:9;21182:4;21178:20;21174:1;21163:9;21159:17;21152:47;21216:131;21342:4;21216:131;:::i;:::-;21208:139;;20935:419;;;:::o;21360:171::-;21500:23;21496:1;21488:6;21484:14;21477:47;21360:171;:::o;21537:366::-;21679:3;21700:67;21764:2;21759:3;21700:67;:::i;:::-;21693:74;;21776:93;21865:3;21776:93;:::i;:::-;21894:2;21889:3;21885:12;21878:19;;21537:366;;;:::o;21909:419::-;22075:4;22113:2;22102:9;22098:18;22090:26;;22162:9;22156:4;22152:20;22148:1;22137:9;22133:17;22126:47;22190:131;22316:4;22190:131;:::i;:::-;22182:139;;21909:419;;;:::o;22334:148::-;22436:11;22473:3;22458:18;;22334:148;;;;:::o;22512:874::-;22615:3;22652:5;22646:12;22681:36;22707:9;22681:36;:::i;:::-;22733:89;22815:6;22810:3;22733:89;:::i;:::-;22726:96;;22853:1;22842:9;22838:17;22869:1;22864:166;;;;23044:1;23039:341;;;;22831:549;;22864:166;22948:4;22944:9;22933;22929:25;22924:3;22917:38;23010:6;23003:14;22996:22;22988:6;22984:35;22979:3;22975:45;22968:52;;22864:166;;23039:341;23106:38;23138:5;23106:38;:::i;:::-;23166:1;23180:154;23194:6;23191:1;23188:13;23180:154;;;23268:7;23262:14;23258:1;23253:3;23249:11;23242:35;23318:1;23309:7;23305:15;23294:26;;23216:4;23213:1;23209:12;23204:17;;23180:154;;;23363:6;23358:3;23354:16;23347:23;;23046:334;;22831:549;;22619:767;;22512:874;;;;:::o;23392:390::-;23498:3;23526:39;23559:5;23526:39;:::i;:::-;23581:89;23663:6;23658:3;23581:89;:::i;:::-;23574:96;;23679:65;23737:6;23732:3;23725:4;23718:5;23714:16;23679:65;:::i;:::-;23769:6;23764:3;23760:16;23753:23;;23502:280;23392:390;;;;:::o;23788:155::-;23928:7;23924:1;23916:6;23912:14;23905:31;23788:155;:::o;23949:400::-;24109:3;24130:84;24212:1;24207:3;24130:84;:::i;:::-;24123:91;;24223:93;24312:3;24223:93;:::i;:::-;24341:1;24336:3;24332:11;24325:18;;23949:400;;;:::o;24355:695::-;24633:3;24655:92;24743:3;24734:6;24655:92;:::i;:::-;24648:99;;24764:95;24855:3;24846:6;24764:95;:::i;:::-;24757:102;;24876:148;25020:3;24876:148;:::i;:::-;24869:155;;25041:3;25034:10;;24355:695;;;;;:::o;25056:423::-;25197:4;25235:2;25224:9;25220:18;25212:26;;25248:71;25316:1;25305:9;25301:17;25292:6;25248:71;:::i;:::-;25366:9;25360:4;25356:20;25351:2;25340:9;25336:18;25329:48;25394:78;25467:4;25458:6;25394:78;:::i;:::-;25386:86;;25056:423;;;;;:::o;25485:160::-;25605:7;25634:5;25623:16;;25485:160;;;:::o;25651:77::-;25688:7;25717:5;25706:16;;25651:77;;;:::o;25734:92::-;25766:8;25813:5;25810:1;25806:13;25785:34;;25734:92;;;:::o;25832:312::-;25965:9;25998:140;26016:121;26029:107;26130:5;26029:107;:::i;:::-;26016:121;:::i;:::-;25998:140;:::i;:::-;25985:153;;25832:312;;;:::o;26150:297::-;26320:120;26434:5;26320:120;:::i;:::-;26315:3;26308:133;26150:297;;:::o;26453:388::-;26629:4;26667:2;26656:9;26652:18;26644:26;;26680:154;26831:1;26820:9;26816:17;26807:6;26680:154;:::i;:::-;26453:388;;;;:::o;26847:117::-;26956:1;26953;26946:12;27093:90;27128:7;27171:5;27168:1;27157:20;27146:31;;27093:90;;;:::o;27189:118::-;27260:22;27276:5;27260:22;:::i;:::-;27253:5;27250:33;27240:61;;27297:1;27294;27287:12;27240:61;27189:118;:::o;27313:139::-;27368:5;27399:6;27393:13;27384:22;;27415:31;27440:5;27415:31;:::i;:::-;27313:139;;;;:::o;27458:101::-;27494:7;27534:18;27527:5;27523:30;27512:41;;27458:101;;;:::o;27565:120::-;27637:23;27654:5;27637:23;:::i;:::-;27630:5;27627:34;27617:62;;27675:1;27672;27665:12;27617:62;27565:120;:::o;27691:141::-;27747:5;27778:6;27772:13;27763:22;;27794:32;27820:5;27794:32;:::i;:::-;27691:141;;;;:::o;27838:90::-;27873:7;27916:5;27913:1;27902:20;27891:31;;27838:90;;;:::o;27934:118::-;28005:22;28021:5;28005:22;:::i;:::-;27998:5;27995:33;27985:61;;28042:1;28039;28032:12;27985:61;27934:118;:::o;28058:139::-;28113:5;28144:6;28138:13;28129:22;;28160:31;28185:5;28160:31;:::i;:::-;28058:139;;;;:::o;28203:143::-;28260:5;28291:6;28285:13;28276:22;;28307:33;28334:5;28307:33;:::i;:::-;28203:143;;;;:::o;28384:950::-;28465:5;28509:4;28497:9;28492:3;28488:19;28484:30;28481:117;;;28517:79;;:::i;:::-;28481:117;28616:21;28632:4;28616:21;:::i;:::-;28607:30;;28697:1;28737:58;28791:3;28782:6;28771:9;28767:22;28737:58;:::i;:::-;28730:4;28723:5;28719:16;28712:84;28647:160;28866:2;28907:59;28962:3;28953:6;28942:9;28938:22;28907:59;:::i;:::-;28900:4;28893:5;28889:16;28882:85;28817:161;29037:2;29078:58;29132:3;29123:6;29112:9;29108:22;29078:58;:::i;:::-;29071:4;29064:5;29060:16;29053:84;28988:160;29214:2;29255:60;29311:3;29302:6;29291:9;29287:22;29255:60;:::i;:::-;29248:4;29241:5;29237:16;29230:86;29158:169;28384:950;;;;:::o;29340:394::-;29431:6;29480:3;29468:9;29459:7;29455:23;29451:33;29448:120;;;29487:79;;:::i;:::-;29448:120;29607:1;29632:85;29709:7;29700:6;29689:9;29685:22;29632:85;:::i;:::-;29622:95;;29578:149;29340:394;;;;:::o;29740:107::-;29776:7;29816:24;29809:5;29805:36;29794:47;;29740:107;;;:::o;29853:180::-;29901:77;29898:1;29891:88;29998:4;29995:1;29988:15;30022:4;30019:1;30012:15;30039:182;30078:1;30095:19;30112:1;30095:19;:::i;:::-;30090:24;;30128:19;30145:1;30128:19;:::i;:::-;30123:24;;30166:1;30156:35;;30171:18;;:::i;:::-;30156:35;30213:1;30210;30206:9;30201:14;;30039:182;;;;:::o;30227:164::-;30367:16;30363:1;30355:6;30351:14;30344:40;30227:164;:::o;30397:366::-;30539:3;30560:67;30624:2;30619:3;30560:67;:::i;:::-;30553:74;;30636:93;30725:3;30636:93;:::i;:::-;30754:2;30749:3;30745:12;30738:19;;30397:366;;;:::o;30769:419::-;30935:4;30973:2;30962:9;30958:18;30950:26;;31022:9;31016:4;31012:20;31008:1;30997:9;30993:17;30986:47;31050:131;31176:4;31050:131;:::i;:::-;31042:139;;30769:419;;;:::o;31194:299::-;31334:34;31330:1;31322:6;31318:14;31311:58;31403:34;31398:2;31390:6;31386:15;31379:59;31472:13;31467:2;31459:6;31455:15;31448:38;31194:299;:::o;31499:366::-;31641:3;31662:67;31726:2;31721:3;31662:67;:::i;:::-;31655:74;;31738:93;31827:3;31738:93;:::i;:::-;31856:2;31851:3;31847:12;31840:19;;31499:366;;;:::o;31871:419::-;32037:4;32075:2;32064:9;32060:18;32052:26;;32124:9;32118:4;32114:20;32110:1;32099:9;32095:17;32088:47;32152:131;32278:4;32152:131;:::i;:::-;32144:139;;31871:419;;;:::o;32296:222::-;32436:34;32432:1;32424:6;32420:14;32413:58;32505:5;32500:2;32492:6;32488:15;32481:30;32296:222;:::o;32524:366::-;32666:3;32687:67;32751:2;32746:3;32687:67;:::i;:::-;32680:74;;32763:93;32852:3;32763:93;:::i;:::-;32881:2;32876:3;32872:12;32865:19;;32524:366;;;:::o;32896:419::-;33062:4;33100:2;33089:9;33085:18;33077:26;;33149:9;33143:4;33139:20;33135:1;33124:9;33120:17;33113:47;33177:131;33303:4;33177:131;:::i;:::-;33169:139;;32896:419;;;:::o;33321:351::-;33391:6;33440:2;33428:9;33419:7;33415:23;33411:32;33408:119;;;33446:79;;:::i;:::-;33408:119;33566:1;33591:64;33647:7;33638:6;33627:9;33623:22;33591:64;:::i;:::-;33581:74;;33537:128;33321:351;;;;:::o;33678:300::-;33818:34;33814:1;33806:6;33802:14;33795:58;33887:34;33882:2;33874:6;33870:15;33863:59;33956:14;33951:2;33943:6;33939:15;33932:39;33678:300;:::o;33984:366::-;34126:3;34147:67;34211:2;34206:3;34147:67;:::i;:::-;34140:74;;34223:93;34312:3;34223:93;:::i;:::-;34341:2;34336:3;34332:12;34325:19;;33984:366;;;:::o;34356:419::-;34522:4;34560:2;34549:9;34545:18;34537:26;;34609:9;34603:4;34599:20;34595:1;34584:9;34580:17;34573:47;34637:131;34763:4;34637:131;:::i;:::-;34629:139;;34356:419;;;:::o;34781:169::-;34921:21;34917:1;34909:6;34905:14;34898:45;34781:169;:::o;34956:366::-;35098:3;35119:67;35183:2;35178:3;35119:67;:::i;:::-;35112:74;;35195:93;35284:3;35195:93;:::i;:::-;35313:2;35308:3;35304:12;35297:19;;34956:366;;;:::o;35328:419::-;35494:4;35532:2;35521:9;35517:18;35509:26;;35581:9;35575:4;35571:20;35567:1;35556:9;35552:17;35545:47;35609:131;35735:4;35609:131;:::i;:::-;35601:139;;35328:419;;;:::o;35753:181::-;35893:33;35889:1;35881:6;35877:14;35870:57;35753:181;:::o;35940:366::-;36082:3;36103:67;36167:2;36162:3;36103:67;:::i;:::-;36096:74;;36179:93;36268:3;36179:93;:::i;:::-;36297:2;36292:3;36288:12;36281:19;;35940:366;;;:::o;36312:419::-;36478:4;36516:2;36505:9;36501:18;36493:26;;36565:9;36559:4;36555:20;36551:1;36540:9;36536:17;36529:47;36593:131;36719:4;36593:131;:::i;:::-;36585:139;;36312:419;;;:::o;36737:181::-;36877:33;36873:1;36865:6;36861:14;36854:57;36737:181;:::o;36924:366::-;37066:3;37087:67;37151:2;37146:3;37087:67;:::i;:::-;37080:74;;37163:93;37252:3;37163:93;:::i;:::-;37281:2;37276:3;37272:12;37265:19;;36924:366;;;:::o;37296:419::-;37462:4;37500:2;37489:9;37485:18;37477:26;;37549:9;37543:4;37539:20;37535:1;37524:9;37520:17;37513:47;37577:131;37703:4;37577:131;:::i;:::-;37569:139;;37296:419;;;:::o;37721:214::-;37861:66;37857:1;37849:6;37845:14;37838:90;37721:214;:::o;37941:402::-;38101:3;38122:85;38204:2;38199:3;38122:85;:::i;:::-;38115:92;;38216:93;38305:3;38216:93;:::i;:::-;38334:2;38329:3;38325:12;38318:19;;37941:402;;;:::o;38349:79::-;38388:7;38417:5;38406:16;;38349:79;;;:::o;38434:157::-;38539:45;38559:24;38577:5;38559:24;:::i;:::-;38539:45;:::i;:::-;38534:3;38527:58;38434:157;;:::o;38597:522::-;38810:3;38832:148;38976:3;38832:148;:::i;:::-;38825:155;;38990:75;39061:3;39052:6;38990:75;:::i;:::-;39090:2;39085:3;39081:12;39074:19;;39110:3;39103:10;;38597:522;;;;:::o;39125:174::-;39265:26;39261:1;39253:6;39249:14;39242:50;39125:174;:::o;39305:366::-;39447:3;39468:67;39532:2;39527:3;39468:67;:::i;:::-;39461:74;;39544:93;39633:3;39544:93;:::i;:::-;39662:2;39657:3;39653:12;39646:19;;39305:366;;;:::o;39677:419::-;39843:4;39881:2;39870:9;39866:18;39858:26;;39930:9;39924:4;39920:20;39916:1;39905:9;39901:17;39894:47;39958:131;40084:4;39958:131;:::i;:::-;39950:139;;39677:419;;;:::o;40102:86::-;40137:7;40177:4;40170:5;40166:16;40155:27;;40102:86;;;:::o;40194:188::-;40232:3;40251:18;40267:1;40251:18;:::i;:::-;40246:23;;40283:18;40299:1;40283:18;:::i;:::-;40278:23;;40324:1;40321;40317:9;40310:16;;40347:4;40342:3;40339:13;40336:39;;;40355:18;;:::i;:::-;40336:39;40194:188;;;;:::o;40388:177::-;40528:29;40524:1;40516:6;40512:14;40505:53;40388:177;:::o;40571:366::-;40713:3;40734:67;40798:2;40793:3;40734:67;:::i;:::-;40727:74;;40810:93;40899:3;40810:93;:::i;:::-;40928:2;40923:3;40919:12;40912:19;;40571:366;;;:::o;40943:419::-;41109:4;41147:2;41136:9;41132:18;41124:26;;41196:9;41190:4;41186:20;41182:1;41171:9;41167:17;41160:47;41224:131;41350:4;41224:131;:::i;:::-;41216:139;;40943:419;;;:::o;41368:118::-;41455:24;41473:5;41455:24;:::i;:::-;41450:3;41443:37;41368:118;;:::o;41492:112::-;41575:22;41591:5;41575:22;:::i;:::-;41570:3;41563:35;41492:112;;:::o;41610:545::-;41783:4;41821:3;41810:9;41806:19;41798:27;;41835:71;41903:1;41892:9;41888:17;41879:6;41835:71;:::i;:::-;41916:68;41980:2;41969:9;41965:18;41956:6;41916:68;:::i;:::-;41994:72;42062:2;42051:9;42047:18;42038:6;41994:72;:::i;:::-;42076;42144:2;42133:9;42129:18;42120:6;42076:72;:::i;:::-;41610:545;;;;;;;:::o;42161:233::-;42200:3;42223:24;42241:5;42223:24;:::i;:::-;42214:33;;42269:66;42262:5;42259:77;42256:103;;42339:18;;:::i;:::-;42256:103;42386:1;42379:5;42375:13;42368:20;;42161:233;;;:::o;42400:185::-;42440:1;42457:20;42475:1;42457:20;:::i;:::-;42452:25;;42491:20;42509:1;42491:20;:::i;:::-;42486:25;;42530:1;42520:35;;42535:18;;:::i;:::-;42520:35;42577:1;42574;42570:9;42565:14;;42400:185;;;;:::o;42591:194::-;42631:4;42651:20;42669:1;42651:20;:::i;:::-;42646:25;;42685:20;42703:1;42685:20;:::i;:::-;42680:25;;42729:1;42726;42722:9;42714:17;;42753:1;42747:4;42744:11;42741:37;;;42758:18;;:::i;:::-;42741:37;42591:194;;;;:::o;42791:176::-;42823:1;42840:20;42858:1;42840:20;:::i;:::-;42835:25;;42874:20;42892:1;42874:20;:::i;:::-;42869:25;;42913:1;42903:35;;42918:18;;:::i;:::-;42903:35;42959:1;42956;42952:9;42947:14;;42791:176;;;;:::o

ipfs://a83d20001616790f22d28c4b615d6e846d31ef3ad51041b5c7cb5a06b8c622f9