Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _nonReentrantBefore()
•    - function _nonReentrantAfter()
•    - function _reentrancyGuardEntered()
• library Address
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(bool succes ...
•    - function _revert(bytes memory returnd ...
•    - function nonces(address owner)
•    - function _useNonce(address owner)
•    - function _useCheckedNonce(address own ...
• interface IERC5267
•    - function eip712Domain()
• library StorageSlot
•    - function getAddressSlot(bytes32 slot)
•    - function getBooleanSlot(bytes32 slot)
•    - function getBytes32Slot(bytes32 slot)
•    - function getUint256Slot(bytes32 slot)
•    - function getStringSlot(bytes32 slot)
•    - function getStringSlot(string storage ...
•    - function getBytesSlot(bytes32 slot)
•    - function getBytesSlot(bytes storage s ...
• library ShortStrings
•    - function toShortString(string memory ...
•    - function toString(ShortString sstr)
•    - function byteLength(ShortString sstr)
•    - function toShortStringWithFallback(st ...
•    - function toStringWithFallback(ShortSt ...
•    - function byteLengthWithFallback(Short ...
• library SignedMath
•    - function max(int256 a, int256 b)
•    - function min(int256 a, int256 b)
•    - function average(int256 a, int256 b)
•    - function abs(int256 n)
• library Math
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•    - function log2(uint256 value)
•    - function log2(uint256 value, Rounding ...
•    - function log10(uint256 value)
•    - function log10(uint256 value, Roundin ...
•    - function log256(uint256 value)
•    - function log256(uint256 value, Roundi ...
•    - function unsignedRoundsUp(Rounding ro ...
• library Strings
•    - function toString(uint256 value)
•    - function toStringSigned(int256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
•    - function equal(string memory a, strin ...
• library MessageHashUtils
•    - function toEthSignedMessageHash(bytes ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toDataWithIntendedValidatorH ...
•    - function toTypedDataHash(bytes32 doma ...
•    - function _domainSeparatorV4()
•    - function _buildDomainSeparator()
•    - function _hashTypedDataV4(bytes32 str ...
•    - function eip712Domain()
•    - function _EIP712Name()
•    - function _EIP712Version()
• library ECDSA
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes3 ...
•    - function tryRecover(
•    - function recover(bytes32 hash, uint8 ...
•    - function _throwError(RecoverError err ...
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• interface IERC20Errors
• interface IERC721Errors
• interface IERC1155Errors
•    - function _msgSender()
•    - function _msgData()
•    - function _contextSuffixLength()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function forceApprove(IERC20 token, a ...
•    - function _callOptionalReturn(IERC20 t ...
•    - function _callOptionalReturnBool(IERC ...
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
•    - function _transfer(address from, addr ...
•    - function _update(address from, addres ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _approve(address owner, addr ...
•    - function _spendAllowance(address owne ...
•    - function burn(uint256 value)
•    - function burnFrom(address account, ui ...
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
•  contract QuantCoin is *
•    - function decimals()
•    - function getRewardAmount(address user ...
•    - function getInviter(address user)
•    - function getActiveState(address user)
•    - function transferForActive(address in ...
•    - function canInvite(address user, addr ...
•    - function depositNoInviter(uint256 amo ...
•    - function depositHaveInviter(uint256 a ...
•    - function transferWithReward(
•    - function isContract(address account)
•    - function withdrawUSDT(uint256 withdra ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-05-20
*/

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


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

pragma solidity ^0.8.20;

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

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

    uint256 private _status;

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

    constructor() {
        _status = NOT_ENTERED;
    }

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

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

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

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

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

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


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

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Nonces.sol)
pragma solidity ^0.8.20;

/**
 * @dev Provides tracking nonces for addresses. Nonces will only increment.
 */
abstract contract Nonces {
    /**
     * @dev The nonce used for an `account` is not the expected current nonce.
     */
    error InvalidAccountNonce(address account, uint256 currentNonce);

    mapping(address account => uint256) private _nonces;

    /**
     * @dev Returns the next unused nonce for an address.
     */
    function nonces(address owner) public view virtual returns (uint256) {
        return _nonces[owner];
    }

    /**
     * @dev Consumes a nonce.
     *
     * Returns the current value and increments nonce.
     */
    function _useNonce(address owner) internal virtual returns (uint256) {
        // For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be
        // decremented or reset. This guarantees that the nonce never overflows.
        unchecked {
            // It is important to do x++ and not ++x here.
            return _nonces[owner]++;
        }
    }

    /**
     * @dev Same as {_useNonce} but checking that `nonce` is the next valid for `owner`.
     */
    function _useCheckedNonce(address owner, uint256 nonce) internal virtual {
        uint256 current = _useNonce(owner);
        if (nonce != current) {
            revert InvalidAccountNonce(owner, current);
        }
    }
}

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


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

pragma solidity ^0.8.20;

interface IERC5267 {
    /**
     * @dev MAY be emitted to signal that the domain could have changed.
     */
    event EIP712DomainChanged();

    /**
     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
     * signature.
     */
    function eip712Domain()
        external
        view
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        );
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(newImplementation.code.length > 0);
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

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


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

pragma solidity ^0.8.20;


// | string  | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA   |
// | length  | 0x                                                              BB |
type ShortString is bytes32;

/**
 * @dev This library provides functions to convert short memory strings
 * into a `ShortString` type that can be used as an immutable variable.
 *
 * Strings of arbitrary length can be optimized using this library if
 * they are short enough (up to 31 bytes) by packing them with their
 * length (1 byte) in a single EVM word (32 bytes). Additionally, a
 * fallback mechanism can be used for every other case.
 *
 * Usage example:
 *
 * ```solidity
 * contract Named {
 *     using ShortStrings for *;
 *
 *     ShortString private immutable _name;
 *     string private _nameFallback;
 *
 *     constructor(string memory contractName) {
 *         _name = contractName.toShortStringWithFallback(_nameFallback);
 *     }
 *
 *     function name() external view returns (string memory) {
 *         return _name.toStringWithFallback(_nameFallback);
 *     }
 * }
 * ```
 */
library ShortStrings {
    // Used as an identifier for strings longer than 31 bytes.
    bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;

    error StringTooLong(string str);
    error InvalidShortString();

    /**
     * @dev Encode a string of at most 31 chars into a `ShortString`.
     *
     * This will trigger a `StringTooLong` error is the input string is too long.
     */
    function toShortString(string memory str) internal pure returns (ShortString) {
        bytes memory bstr = bytes(str);
        if (bstr.length > 31) {
            revert StringTooLong(str);
        }
        return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
    }

    /**
     * @dev Decode a `ShortString` back to a "normal" string.
     */
    function toString(ShortString sstr) internal pure returns (string memory) {
        uint256 len = byteLength(sstr);
        // using `new string(len)` would work locally but is not memory safe.
        string memory str = new string(32);
        /// @solidity memory-safe-assembly
        assembly {
            mstore(str, len)
            mstore(add(str, 0x20), sstr)
        }
        return str;
    }

    /**
     * @dev Return the length of a `ShortString`.
     */
    function byteLength(ShortString sstr) internal pure returns (uint256) {
        uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
        if (result > 31) {
            revert InvalidShortString();
        }
        return result;
    }

    /**
     * @dev Encode a string into a `ShortString`, or write it to storage if it is too long.
     */
    function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
        if (bytes(value).length < 32) {
            return toShortString(value);
        } else {
            StorageSlot.getStringSlot(store).value = value;
            return ShortString.wrap(FALLBACK_SENTINEL);
        }
    }

    /**
     * @dev Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}.
     */
    function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
        if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
            return toString(value);
        } else {
            return store;
        }
    }

    /**
     * @dev Return the length of a string that was encoded to `ShortString` or written to storage using
     * {setWithFallback}.
     *
     * WARNING: This will return the "byte length" of the string. This may not reflect the actual length in terms of
     * actual characters as the UTF-8 encoding of a single character can span over multiple bytes.
     */
    function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
        if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
            return byteLength(value);
        } else {
            return bytes(store).length;
        }
    }
}

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


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

pragma solidity ^0.8.20;

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

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

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

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

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


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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

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

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

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

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

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

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

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

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.20;



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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol


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

pragma solidity ^0.8.20;


/**
 * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.
 *
 * The library provides methods for generating a hash of a message that conforms to the
 * https://eips.ethereum.org/EIPS/eip-191[EIP 191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]
 * specifications.
 */
library MessageHashUtils {
    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing a bytes32 `messageHash` with
     * `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the
     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with
     * keccak256, although any bytes32 value can be safely used because the final digest will
     * be re-hashed.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32") // 32 is the bytes-length of messageHash
            mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix
            digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)
        }
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing an arbitrary `message` with
     * `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the
     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
        return
            keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x00` (data with intended validator).
     *
     * The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and the intended
     * `validator` address. Then hashing the result.
     *
     * See {ECDSA-recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked(hex"19_00", validator, data));
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`).
     *
     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with
     * `\x19\x01` and hashing the result. It corresponds to the hash signed by the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.
     *
     * See {ECDSA-recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, hex"19_01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            digest := keccak256(ptr, 0x42)
        }
    }
}

// File: @openzeppelin/contracts/utils/cryptography/EIP712.sol


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

pragma solidity ^0.8.20;




/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose
 * encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract
 * does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to
 * produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain
 * separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the
 * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.
 *
 * @custom:oz-upgrades-unsafe-allow state-variable-immutable
 */
abstract contract EIP712 is IERC5267 {
    using ShortStrings for *;

    bytes32 private constant TYPE_HASH =
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _cachedDomainSeparator;
    uint256 private immutable _cachedChainId;
    address private immutable _cachedThis;

    bytes32 private immutable _hashedName;
    bytes32 private immutable _hashedVersion;

    ShortString private immutable _name;
    ShortString private immutable _version;
    string private _nameFallback;
    string private _versionFallback;

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        _name = name.toShortStringWithFallback(_nameFallback);
        _version = version.toShortStringWithFallback(_versionFallback);
        _hashedName = keccak256(bytes(name));
        _hashedVersion = keccak256(bytes(version));

        _cachedChainId = block.chainid;
        _cachedDomainSeparator = _buildDomainSeparator();
        _cachedThis = address(this);
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
            return _cachedDomainSeparator;
        } else {
            return _buildDomainSeparator();
        }
    }

    function _buildDomainSeparator() private view returns (bytes32) {
        return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
    }

    /**
     * @dev See {IERC-5267}.
     */
    function eip712Domain()
        public
        view
        virtual
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        )
    {
        return (
            hex"0f", // 01111
            _EIP712Name(),
            _EIP712Version(),
            block.chainid,
            address(this),
            bytes32(0),
            new uint256[](0)
        );
    }

    /**
     * @dev The name parameter for the EIP712 domain.
     *
     * NOTE: By default this function reads _name which is an immutable value.
     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).
     */
    // solhint-disable-next-line func-name-mixedcase
    function _EIP712Name() internal view returns (string memory) {
        return _name.toStringWithFallback(_nameFallback);
    }

    /**
     * @dev The version parameter for the EIP712 domain.
     *
     * NOTE: By default this function reads _version which is an immutable value.
     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).
     */
    // solhint-disable-next-line func-name-mixedcase
    function _EIP712Version() internal view returns (string memory) {
        return _version.toStringWithFallback(_versionFallback);
    }
}

// File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol


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

pragma solidity ^0.8.20;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS
    }

    /**
     * @dev The signature derives the `address(0)`.
     */
    error ECDSAInvalidSignature();

    /**
     * @dev The signature has an invalid length.
     */
    error ECDSAInvalidSignatureLength(uint256 length);

    /**
     * @dev The signature has an S value that is in the upper half order.
     */
    error ECDSAInvalidSignatureS(bytes32 s);

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
     * return address(0) without also returning an error description. Errors are documented using an enum (error type)
     * and a bytes32 providing additional information about the error.
     *
     * If no error is returned, then the address can be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
        unchecked {
            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            // We do not check for an overflow here since the shift operation results in 0 or 1.
            uint8 v = uint8((uint256(vs) >> 255) + 27);
            return tryRecover(hash, v, r, s);
        }
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError, bytes32) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS, s);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature, bytes32(0));
        }

        return (signer, RecoverError.NoError, bytes32(0));
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
     */
    function _throwError(RecoverError error, bytes32 errorArg) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert ECDSAInvalidSignature();
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert ECDSAInvalidSignatureLength(uint256(errorArg));
        } else if (error == RecoverError.InvalidSignatureS) {
            revert ECDSAInvalidSignatureS(errorArg);
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// File: @openzeppelin/contracts/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/contracts/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/contracts/access/Ownable.sol


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

pragma solidity ^0.8.20;


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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

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


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

pragma solidity ^0.8.20;





/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     * ```
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Burnable.sol)

pragma solidity ^0.8.20;



/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys a `value` amount of tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 value) public virtual {
        _burn(_msgSender(), value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, deducting from
     * the caller's allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `value`.
     */
    function burnFrom(address account, uint256 value) public virtual {
        _spendAllowance(account, _msgSender(), value);
        _burn(account, value);
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Permit.sol)

pragma solidity ^0.8.20;






/**
 * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712, Nonces {
    bytes32 private constant PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    /**
     * @dev Permit deadline has expired.
     */
    error ERC2612ExpiredSignature(uint256 deadline);

    /**
     * @dev Mismatched signature.
     */
    error ERC2612InvalidSigner(address signer, address owner);

    /**
     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
     *
     * It's a good idea to use the same `name` that is defined as the ERC20 token name.
     */
    constructor(string memory name) EIP712(name, "1") {}

    /**
     * @inheritdoc IERC20Permit
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual {
        if (block.timestamp > deadline) {
            revert ERC2612ExpiredSignature(deadline);
        }

        bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));

        bytes32 hash = _hashTypedDataV4(structHash);

        address signer = ECDSA.recover(hash, v, r, s);
        if (signer != owner) {
            revert ERC2612InvalidSigner(signer, owner);
        }

        _approve(owner, spender, value);
    }

    /**
     * @inheritdoc IERC20Permit
     */
    function nonces(address owner) public view virtual override(IERC20Permit, Nonces) returns (uint256) {
        return super.nonces(owner);
    }

    /**
     * @inheritdoc IERC20Permit
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view virtual returns (bytes32) {
        return _domainSeparatorV4();
    }
}

// File: contracts/quant_token.sol

pragma solidity ^0.8.24;








contract QuantCoin is
    ERC20,
    ERC20Permit,
    ReentrancyGuard,
    Ownable,
    ERC20Burnable
{
    using SafeERC20 for IERC20;
    mapping(address => address) private inviter;
    mapping(address => bool) private isActive;
    mapping(address => uint256) private _rewardAmount;
    address public constant USDT_ADDRESS =
        0xdAC17F958D2ee523a2206206994597C13D831ec7;
    uint256 private immutable MIN_ACTIVATION_AMOUNT = 10 * 10**decimals();
    uint256 private immutable HAVE_INVITER_REWARDS_RATIO = 70;
    uint256 private immutable NOT_INVITER_RATIO = 63;
    uint16 private QC_TO_USDT_RATIO = 1000;
    event Reward(
        address indexed rewardAddress,
        uint256 rewardAmount,
        uint256 timeStamp
    );

    constructor(address initialOwner)
        ERC20("Quant Coin", "QC")
        ERC20Permit("Quant Coin")
        Ownable(initialOwner)
    {
        _mint(msg.sender, 10000000000 * 10**decimals());
    }

    function decimals() public pure override returns (uint8) {
        return 6;
    }

    function getRewardAmount(address user) public view returns (uint256) {
        return _rewardAmount[user];
    }

    function getInviter(address user) public view returns (address) {
        return inviter[user];
    }

    function getActiveState(address user) public view returns (bool) {
        return isActive[user];
    }

    function transferForActive(address inviteAddress, uint256 amount)
        external
        nonReentrant
    {
        require(inviteAddress != msg.sender, "Cannot invite yourself");
        require(
            amount >= MIN_ACTIVATION_AMOUNT,
            "The activation amount must be greater than or equal to 10"
        );
        require(isContract(msg.sender) != true, "unsupport contract address");
        IERC20 token = IERC20(USDT_ADDRESS);
        token.safeTransferFrom(msg.sender, address(this), amount);
        uint256 nowSupplyAmount = balanceOf(owner());
        if (inviteAddress == address(0)) {
            if (inviter[msg.sender] != address(0)) {
                //not have inviter address ,but it has been deposited before
                depositHaveInviter(amount, nowSupplyAmount);
            } else {
                //not have  inviter address and first deposit
                depositNoInviter(amount, nowSupplyAmount);
            }
        } else {
            // pass inviter address
            bool shouldInvite = canInvite(msg.sender, inviteAddress);
            if (shouldInvite) {
                //  set inviter  relationship
                inviter[msg.sender] = inviteAddress;
                //depoist and transfer for reward inviter
                depositHaveInviter(amount, nowSupplyAmount);
            } else {
                // not  invite
                if (inviter[msg.sender] != address(0)) {
                    // msg.sender has  the inviter relationship、
                    depositHaveInviter(amount, nowSupplyAmount);
                } else {
                    //  msg.sender not have inviter relationship,but inviter address is not
                    depositNoInviter(amount, nowSupplyAmount);
                }
            }
        }
    }

    function canInvite(address user, address inviteAddress)
        private
        view
        returns (bool)
    {
        bool isNotPreOrNextPre = true;
        address cur = inviteAddress;
        for (uint8 i = 0; i < 2; i++) {
            cur = inviter[cur];
            if (cur == address(0)) {
                break;
            }
            if (cur == user) {
                isNotPreOrNextPre = false;
            }
        }
        bool shouldInvite = (isNotPreOrNextPre &&
            inviter[user] == address(0) &&
            !isContract(inviteAddress) &&
            isActive[inviteAddress] == true);

        return shouldInvite;
    }

    function depositNoInviter(uint256 amount, uint256 nowSupplyAmount) public {
        if (isActive[msg.sender] != true) {
            isActive[msg.sender] = true;
        }
        _update(
            owner(),
            msg.sender,
            ((amount *
                QC_TO_USDT_RATIO *
                nowSupplyAmount *
                NOT_INVITER_RATIO) / 100) / totalSupply()
        );
    }

    function depositHaveInviter(uint256 amount, uint256 nowSupplyAmount)
        public
    {
        if (isActive[msg.sender] != true) {
            isActive[msg.sender] = true;
        }
        transferWithReward(
            msg.sender,
            amount * QC_TO_USDT_RATIO,
            nowSupplyAmount
        );
        _update(
            owner(),
            msg.sender,
            ((amount *
                QC_TO_USDT_RATIO *
                nowSupplyAmount *
                HAVE_INVITER_REWARDS_RATIO) / 100) / totalSupply()
        );
    }

    function transferWithReward(
        address sender,
        uint256 amount,
        uint256 nowSupplyAmount
    ) private {
        address cur = sender;
        uint8[2] memory inviteRate = [20, 10];
        for (uint8 i = 0; i < inviteRate.length; i++) {
            uint8 rate = inviteRate[i];
            cur = inviter[cur];
            if (cur == address(0)) {
                break;
            }
            uint256 rewardAmount = ((((amount * nowSupplyAmount)) /
                totalSupply()) * rate) / 100;
            _rewardAmount[cur] += rewardAmount;
            _update(owner(), cur, rewardAmount);
            emit Reward(cur, rewardAmount, block.timestamp);
        }
    }

    function isContract(address account) internal view returns (bool) {
        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    function withdrawUSDT(uint256 withdrawAmount) external onlyOwner {
        IERC20 token = IERC20(USDT_ADDRESS);
        token.forceApprove(address(this), withdrawAmount);
        token.safeTransfer(owner(), withdrawAmount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"initialOwner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"ECDSAInvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ECDSAInvalidSignatureLength","type":"error"},{"inputs":[{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"ECDSAInvalidSignatureS","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"ERC2612ExpiredSignature","type":"error"},{"inputs":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC2612InvalidSigner","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"currentNonce","type":"uint256"}],"name":"InvalidAccountNonce","type":"error"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"rewardAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"rewardAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timeStamp","type":"uint256"}],"name":"Reward","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"USDT_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"nowSupplyAmount","type":"uint256"}],"name":"depositHaveInviter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"nowSupplyAmount","type":"uint256"}],"name":"depositNoInviter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getActiveState","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getInviter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getRewardAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"inviteAddress","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferForActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"withdrawAmount","type":"uint256"}],"name":"withdrawUSDT","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000006b9d1a2f3d04643a814e5fb65c26d9243dc69412

-----Decoded View---------------
Arg [0] : initialOwner (address): 0x6b9d1A2F3d04643a814e5Fb65c26D9243Dc69412

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000006b9d1a2f3d04643a814e5fb65c26d9243dc69412

98553:6105:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85318:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;87611:190;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;86420:99;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;88379:249;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;99533:84;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;98352:114;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;99971:1843;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;102502:411;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;104422:233;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;95243:89;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;99625:114;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;86582:118;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73154:103;;;:::i;:::-;;99858:105;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;95661:161;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;98094:145;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49666:580;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;72479:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;85528:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;86905:182;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;102921:571;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;98855:90;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;99747:103;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;97340:695;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;87150:142;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73412:220;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;85318:91;85363:13;85396:5;85389:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85318:91;:::o;87611:190::-;87684:4;87701:13;87717:12;:10;:12::i;:::-;87701:28;;87740:31;87749:5;87756:7;87765:5;87740:8;:31::i;:::-;87789:4;87782:11;;;87611:190;;;;:::o;86420:99::-;86472:7;86499:12;;86492:19;;86420:99;:::o;88379:249::-;88466:4;88483:15;88501:12;:10;:12::i;:::-;88483:30;;88524:37;88540:4;88546:7;88555:5;88524:15;:37::i;:::-;88572:26;88582:4;88588:2;88592:5;88572:9;:26::i;:::-;88616:4;88609:11;;;88379:249;;;;;:::o;99533:84::-;99583:5;99608:1;99601:8;;99533:84;:::o;98352:114::-;98411:7;98438:20;:18;:20::i;:::-;98431:27;;98352:114;:::o;99971:1843::-;2442:21;:19;:21::i;:::-;100118:10:::1;100101:27;;:13;:27;;::::0;100093:62:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;100198:21;100188:6;:31;;100166:138;;;;;;;;;;;;:::i;:::-;;;;;;;;;100349:4;100323:30;;:22;100334:10;100323;:22::i;:::-;:30;;::::0;100315:69:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;100395:12;98903:42;100395:35;;100441:57;100464:10;100484:4;100491:6;100441:5;:22;;;;:57;;;;;;:::i;:::-;100509:23;100535:18;100545:7;:5;:7::i;:::-;100535:9;:18::i;:::-;100509:44;;100593:1;100568:27;;:13;:27;;::::0;100564:1243:::1;;100647:1;100616:33;;:7;:19;100624:10;100616:19;;;;;;;;;;;;;;;;;;;;;;;;;:33;;;100612:340;;100748:43;100767:6;100775:15;100748:18;:43::i;:::-;100612:340;;;100895:41;100912:6;100920:15;100895:16;:41::i;:::-;100612:340;100564:1243;;;101021:17;101041:36;101051:10;101063:13;101041:9;:36::i;:::-;101021:56;;101096:12;101092:704;;;101198:13;101176:7;:19;101184:10;101176:19;;;;;;;;;;;;;;;;:35;;;;;;;;;;;;;;;;;;101289:43;101308:6;101316:15;101289:18;:43::i;:::-;101092:704;;;101440:1;101409:33;;:7;:19;101417:10;101409:19;;;;;;;;;;;;;;;;;;;;;;;;;:33;;;101405:376;;101535:43;101554:6;101562:15;101535:18;:43::i;:::-;101405:376;;;101720:41;101737:6;101745:15;101720:16;:41::i;:::-;101405:376;101092:704;100969:838;100564:1243;100082:1732;;2486:20:::0;:18;:20::i;:::-;99971:1843;;:::o;102502:411::-;102615:4;102591:28;;:8;:20;102600:10;102591:20;;;;;;;;;;;;;;;;;;;;;;;;;:28;;;102587:88;;102659:4;102636:8;:20;102645:10;102636:20;;;;;;;;;;;;;;;;:27;;;;;;;;;;;;;;;;;;102587:88;102685:220;102707:7;:5;:7::i;:::-;102729:10;102881:13;:11;:13::i;:::-;102874:3;102853:17;102818:15;102782:16;;;;;;;;;;;102756:42;;:6;:42;;;;:::i;:::-;:77;;;;:::i;:::-;:114;;;;:::i;:::-;102755:122;;;;:::i;:::-;102754:140;;;;:::i;:::-;102685:7;:220::i;:::-;102502:411;;:::o;104422:233::-;72365:13;:11;:13::i;:::-;104498:12:::1;98903:42;104498:35;;104544:49;104571:4;104578:14;104544:5;:18;;;;:49;;;;;:::i;:::-;104604:43;104623:7;:5;:7::i;:::-;104632:14;104604:5;:18;;;;:43;;;;;:::i;:::-;104487:168;104422:233:::0;:::o;95243:89::-;95298:26;95304:12;:10;:12::i;:::-;95318:5;95298;:26::i;:::-;95243:89;:::o;99625:114::-;99685:7;99712:13;:19;99726:4;99712:19;;;;;;;;;;;;;;;;99705:26;;99625:114;;;:::o;86582:118::-;86647:7;86674:9;:18;86684:7;86674:18;;;;;;;;;;;;;;;;86667:25;;86582:118;;;:::o;73154:103::-;72365:13;:11;:13::i;:::-;73219:30:::1;73246:1;73219:18;:30::i;:::-;73154:103::o:0;99858:105::-;99917:4;99941:8;:14;99950:4;99941:14;;;;;;;;;;;;;;;;;;;;;;;;;99934:21;;99858:105;;;:::o;95661:161::-;95737:45;95753:7;95762:12;:10;:12::i;:::-;95776:5;95737:15;:45::i;:::-;95793:21;95799:7;95808:5;95793;:21::i;:::-;95661:161;;:::o;98094:145::-;98185:7;98212:19;98225:5;98212:12;:19::i;:::-;98205:26;;98094:145;;;:::o;49666:580::-;49769:13;49797:18;49830:21;49866:15;49896:25;49936:12;49963:27;50071:13;:11;:13::i;:::-;50099:16;:14;:16::i;:::-;50130:13;50166:4;50194:1;50186:10;;50225:1;50211:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50018:220;;;;;;;;;;;;;;;;;;;;;49666:580;;;;;;;:::o;72479:87::-;72525:7;72552:6;;;;;;;;;;;72545:13;;72479:87;:::o;85528:95::-;85575:13;85608:7;85601:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85528:95;:::o;86905:182::-;86974:4;86991:13;87007:12;:10;:12::i;:::-;86991:28;;87030:27;87040:5;87047:2;87051:5;87030:9;:27::i;:::-;87075:4;87068:11;;;86905:182;;;;:::o;102921:571::-;103050:4;103026:28;;:8;:20;103035:10;103026:20;;;;;;;;;;;;;;;;;;;;;;;;;:28;;;103022:88;;103094:4;103071:8;:20;103080:10;103071:20;;;;;;;;;;;;;;;;:27;;;;;;;;;;;;;;;;;;103022:88;103120:124;103153:10;103187:16;;;;;;;;;;;103178:25;;:6;:25;;;;:::i;:::-;103218:15;103120:18;:124::i;:::-;103255:229;103277:7;:5;:7::i;:::-;103299:10;103460:13;:11;:13::i;:::-;103453:3;103423:26;103388:15;103352:16;;;;;;;;;;;103326:42;;:6;:42;;;;:::i;:::-;:77;;;;:::i;:::-;:123;;;;:::i;:::-;103325:131;;;;:::i;:::-;103324:149;;;;:::i;:::-;103255:7;:229::i;:::-;102921:571;;:::o;98855:90::-;98903:42;98855:90;:::o;99747:103::-;99802:7;99829;:13;99837:4;99829:13;;;;;;;;;;;;;;;;;;;;;;;;;99822:20;;99747:103;;;:::o;97340:695::-;97570:8;97552:15;:26;97548:99;;;97626:8;97602:33;;;;;;;;;;;:::i;:::-;;;;;;;;97548:99;97659:18;96660:95;97718:5;97725:7;97734:5;97741:16;97751:5;97741:9;:16::i;:::-;97759:8;97690:78;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;97680:89;;;;;;97659:110;;97782:12;97797:28;97814:10;97797:16;:28::i;:::-;97782:43;;97838:14;97855:28;97869:4;97875:1;97878;97881;97855:13;:28::i;:::-;97838:45;;97908:5;97898:15;;:6;:15;;;97894:90;;97958:6;97966:5;97937:35;;;;;;;;;;;;:::i;:::-;;;;;;;;97894:90;97996:31;98005:5;98012:7;98021:5;97996:8;:31::i;:::-;97537:498;;;97340:695;;;;;;;:::o;87150:142::-;87230:7;87257:11;:18;87269:5;87257:18;;;;;;;;;;;;;;;:27;87276:7;87257:27;;;;;;;;;;;;;;;;87250:34;;87150:142;;;;:::o;73412:220::-;72365:13;:11;:13::i;:::-;73517:1:::1;73497:22;;:8;:22;;::::0;73493:93:::1;;73571:1;73543:31;;;;;;;;;;;:::i;:::-;;;;;;;;73493:93;73596:28;73615:8;73596:18;:28::i;:::-;73412:220:::0;:::o;70488:98::-;70541:7;70568:10;70561:17;;70488:98;:::o;92438:130::-;92523:37;92532:5;92539:7;92548:5;92555:4;92523:8;:37::i;:::-;92438:130;;;:::o;94154:487::-;94254:24;94281:25;94291:5;94298:7;94281:9;:25::i;:::-;94254:52;;94341:17;94321:16;:37;94317:317;;94398:5;94379:16;:24;94375:132;;;94458:7;94467:16;94485:5;94431:60;;;;;;;;;;;;;:::i;:::-;;;;;;;;94375:132;94550:57;94559:5;94566:7;94594:5;94575:16;:24;94601:5;94550:8;:57::i;:::-;94317:317;94243:398;94154:487;;;:::o;89013:308::-;89113:1;89097:18;;:4;:18;;;89093:88;;89166:1;89139:30;;;;;;;;;;;:::i;:::-;;;;;;;;89093:88;89209:1;89195:16;;:2;:16;;;89191:88;;89264:1;89235:32;;;;;;;;;;;:::i;:::-;;;;;;;;89191:88;89289:24;89297:4;89303:2;89307:5;89289:7;:24::i;:::-;89013:308;;;:::o;48333:268::-;48386:7;48427:11;48410:28;;48418:4;48410:28;;;:63;;;;;48459:14;48442:13;:31;48410:63;48406:188;;;48497:22;48490:29;;;;48406:188;48559:23;:21;:23::i;:::-;48552:30;;48333:268;;:::o;2522:315::-;1820:1;2651:7;;:18;2647:88;;2693:30;;;;;;;;;;;;;;2647:88;1820:1;2812:7;:17;;;;2522:315::o;104218:196::-;104278:4;104295:12;104362:7;104350:20;104342:28;;104405:1;104398:4;:8;104391:15;;;104218:196;;;:::o;78510:190::-;78611:81;78631:5;78653;:18;;;78674:4;78680:2;78684:5;78638:53;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78611:19;:81::i;:::-;78510:190;;;;:::o;101822:672::-;101927:4;101949:22;101974:4;101949:29;;101989:11;102003:13;101989:27;;102032:7;102027:243;102049:1;102045;:5;;;102027:243;;;102078:7;:12;102086:3;102078:12;;;;;;;;;;;;;;;;;;;;;;;;;102072:18;;102124:1;102109:17;;:3;:17;;;102105:63;102147:5;102105:63;102193:4;102186:11;;:3;:11;;;102182:77;;102238:5;102218:25;;102182:77;102052:3;;;;;;;102027:243;;;;102280:17;102301;:61;;;;;102360:1;102335:27;;:7;:13;102343:4;102335:13;;;;;;;;;;;;;;;;;;;;;;;;;:27;;;102301:61;:104;;;;;102380:25;102391:13;102380:10;:25::i;:::-;102379:26;102301:104;:152;;;;;102449:4;102422:31;;:8;:23;102431:13;102422:23;;;;;;;;;;;;;;;;;;;;;;;;;:31;;;102301:152;102280:174;;102474:12;102467:19;;;;;101822:672;;;;:::o;2845:212::-;1777:1;3028:7;:21;;;;2845:212::o;89645:1135::-;89751:1;89735:18;;:4;:18;;;89731:552;;89889:5;89873:12;;:21;;;;;;;:::i;:::-;;;;;;;;89731:552;;;89927:19;89949:9;:15;89959:4;89949:15;;;;;;;;;;;;;;;;89927:37;;89997:5;89983:11;:19;89979:117;;;90055:4;90061:11;90074:5;90030:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;89979:117;90251:5;90237:11;:19;90219:9;:15;90229:4;90219:15;;;;;;;;;;;;;;;:37;;;;89912:371;89731:552;90313:1;90299:16;;:2;:16;;;90295:435;;90481:5;90465:12;;:21;;;;;;;;;;;90295:435;;;90698:5;90681:9;:13;90691:2;90681:13;;;;;;;;;;;;;;;;:22;;;;;;;;;;;90295:435;90762:2;90747:25;;90756:4;90747:25;;;90766:5;90747:25;;;;;;:::i;:::-;;;;;;;;89645:1135;;;:::o;72644:166::-;72715:12;:10;:12::i;:::-;72704:23;;:7;:5;:7::i;:::-;:23;;;72700:103;;72778:12;:10;:12::i;:::-;72751:40;;;;;;;;;;;:::i;:::-;;;;;;;;72700:103;72644:166::o;80136:387::-;80224:25;80267:5;:13;;;80283:7;80292:5;80252:47;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80224:75;;80317:44;80341:5;80348:12;80317:23;:44::i;:::-;80312:204;;80378:71;80398:5;80420;:13;;;80436:7;80445:1;80405:43;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80378:19;:71::i;:::-;80464:40;80484:5;80491:12;80464:19;:40::i;:::-;80312:204;80213:310;80136:387;;;:::o;78103:162::-;78186:71;78206:5;78228;:14;;;78245:2;78249:5;78213:43;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78186:19;:71::i;:::-;78103:162;;;:::o;91674:211::-;91764:1;91745:21;;:7;:21;;;91741:91;;91817:1;91790:30;;;;;;;;;;;:::i;:::-;;;;;;;;91741:91;91842:35;91850:7;91867:1;91871:5;91842:7;:35::i;:::-;91674:211;;:::o;73792:191::-;73866:16;73885:6;;;;;;;;;;;73866:25;;73911:8;73902:6;;:17;;;;;;;;;;;;;;;;;;73966:8;73935:40;;73956:8;73935:40;;;;;;;;;;;;73855:128;73792:191;:::o;10381:109::-;10441:7;10468;:14;10476:5;10468:14;;;;;;;;;;;;;;;;10461:21;;10381:109;;;:::o;50575:128::-;50621:13;50654:41;50681:13;50654:5;:26;;:41;;;;:::i;:::-;50647:48;;50575:128;:::o;51038:137::-;51087:13;51120:47;51150:16;51120:8;:29;;:47;;;;:::i;:::-;51113:54;;51038:137;:::o;103500:710::-;103638:11;103652:6;103638:20;;103669:26;:37;;;;;;;;103699:2;103669:37;;;;;;103703:2;103669:37;;;;;;;103722:7;103717:486;103739:17;103735:1;:21;;;103717:486;;;103778:10;103791;103802:1;103791:13;;;;;;;;;:::i;:::-;;;;;;103778:26;;103825:7;:12;103833:3;103825:12;;;;;;;;;;;;;;;;;;;;;;;;;103819:18;;103871:1;103856:17;;:3;:17;;;103852:63;;103894:5;;;103852:63;103929:20;104027:3;104019:4;103953:70;;104002:13;:11;:13::i;:::-;103965:15;103956:6;:24;;;;:::i;:::-;103954:61;;;;:::i;:::-;103953:70;;;;:::i;:::-;103952:78;;;;:::i;:::-;103929:101;;104067:12;104045:13;:18;104059:3;104045:18;;;;;;;;;;;;;;;;:34;;;;;;;:::i;:::-;;;;;;;;104094:35;104102:7;:5;:7::i;:::-;104111:3;104116:12;104094:7;:35::i;:::-;104156:3;104149:42;;;104161:12;104175:15;104149:42;;;;;;;:::i;:::-;;;;;;;;103763:440;;103758:3;;;;;:::i;:::-;;;;103717:486;;;;103627:583;;103500:710;;;:::o;10611:402::-;10671:7;10978;:14;10986:5;10978:14;;;;;;;;;;;;;;;;:16;;;;;;;;;;;;10971:23;;10611:402;;;:::o;49432:178::-;49509:7;49536:66;49569:20;:18;:20::i;:::-;49591:10;49536:32;:66::i;:::-;49529:73;;49432:178;;;:::o;58172:264::-;58257:7;58278:17;58297:18;58317:16;58337:25;58348:4;58354:1;58357;58360;58337:10;:25::i;:::-;58277:85;;;;;;58373:28;58385:5;58392:8;58373:11;:28::i;:::-;58419:9;58412:16;;;;;58172:264;;;;;;:::o;93419:443::-;93549:1;93532:19;;:5;:19;;;93528:91;;93604:1;93575:32;;;;;;;;;;;:::i;:::-;;;;;;;;93528:91;93652:1;93633:21;;:7;:21;;;93629:92;;93706:1;93678:31;;;;;;;;;;;:::i;:::-;;;;;;;;93629:92;93761:5;93731:11;:18;93743:5;93731:18;;;;;;;;;;;;;;;:27;93750:7;93731:27;;;;;;;;;;;;;;;:35;;;;93781:9;93777:78;;;93828:7;93812:31;;93821:5;93812:31;;;93837:5;93812:31;;;;;;:::i;:::-;;;;;;;;93777:78;93419:443;;;;:::o;48609:181::-;48664:7;46525:95;48723:11;48736:14;48752:13;48775:4;48701:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;48691:91;;;;;;48684:98;;48609:181;:::o;80914:638::-;81338:23;81364:33;81392:4;81372:5;81364:27;;;;:33;;;;:::i;:::-;81338:59;;81433:1;81412:10;:17;:22;;:57;;;;;81450:10;81439:30;;;;;;;;;;;;:::i;:::-;81438:31;81412:57;81408:137;;;81526:5;81493:40;;;;;;;;;;;:::i;:::-;;;;;;;;81408:137;80984:568;80914:638;;:::o;82063:585::-;82146:4;82453:12;82467:23;82502:5;82494:19;;82514:4;82494:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82452:67;;;;82537:7;:69;;;;;82570:1;82549:10;:17;:22;:56;;;;82586:10;82575:30;;;;;;;;;;;;:::i;:::-;82549:56;82537:69;:103;;;;;82639:1;82618:5;82610:26;;;:30;82537:103;82530:110;;;;82063:585;;;;:::o;19721:273::-;19815:13;17667:66;19874:17;;19864:5;19845:46;19841:146;;19915:15;19924:5;19915:8;:15::i;:::-;19908:22;;;;19841:146;19970:5;19963:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19721:273;;;;;:::o;44132:410::-;44225:14;44337:4;44331:11;44368:10;44363:3;44356:23;44416:15;44409:4;44404:3;44400:14;44393:39;44469:10;44462:4;44457:3;44453:14;44446:34;44519:4;44514:3;44504:20;44494:30;;44305:230;44132:410;;;;:::o;56477:1556::-;56608:7;56617:12;56631:7;57551:66;57546:1;57538:10;;:79;57534:166;;;57650:1;57654:30;57686:1;57634:54;;;;;;;;57534:166;57797:14;57814:24;57824:4;57830:1;57833;57836;57814:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57797:41;;57871:1;57853:20;;:6;:20;;;57849:115;;57906:1;57910:29;57949:1;57941:10;;57890:62;;;;;;;;;57849:115;57984:6;57992:20;58022:1;58014:10;;57976:49;;;;;;;56477:1556;;;;;;;;;:::o;58574:542::-;58670:20;58661:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;58657:452;58707:7;58657:452;58768:29;58759:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;58755:354;;58821:23;;;;;;;;;;;;;;58755:354;58875:35;58866:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;58862:247;;58970:8;58962:17;;58934:46;;;;;;;;;;;:::i;:::-;;;;;;;;58862:247;59011:30;59002:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;58998:111;;59088:8;59065:32;;;;;;;;;;;:::i;:::-;;;;;;;;58998:111;58574:542;;;:::o;6154:153::-;6229:12;6261:38;6283:6;6291:4;6297:1;6261:21;:38::i;:::-;6254:45;;6154:153;;;;:::o;18376:415::-;18435:13;18461:11;18475:16;18486:4;18475:10;:16::i;:::-;18461:30;;18581:17;18612:2;18601:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18581:34;;18706:3;18701;18694:16;18747:4;18740;18735:3;18731:14;18724:28;18780:3;18773:10;;;;18376:415;;;:::o;6642:398::-;6741:12;6794:5;6770:21;:29;6766:110;;;6858:4;6823:41;;;;;;;;;;;:::i;:::-;;;;;;;;6766:110;6887:12;6901:23;6928:6;:11;;6947:5;6954:4;6928:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6886:73;;;;6977:55;7004:6;7012:7;7021:10;6977:26;:55::i;:::-;6970:62;;;;6642:398;;;;;:::o;18868:251::-;18929:7;18949:14;19002:4;18993;18966:33;;:40;18949:57;;19030:2;19021:6;:11;19017:71;;;19056:20;;;;;;;;;;;;;;19017:71;19105:6;19098:13;;;18868:251;;;:::o;8118:597::-;8266:12;8296:7;8291:417;;8320:19;8328:10;8320:7;:19::i;:::-;8291:417;;;8569:1;8548:10;:17;:22;:49;;;;;8596:1;8574:6;:18;;;:23;8548:49;8544:121;;;8642:6;8625:24;;;;;;;;;;;:::i;:::-;;;;;;;;8544:121;8686:10;8679:17;;;;8291:417;8118:597;;;;;;:::o;9268:528::-;9421:1;9401:10;:17;:21;9397:392;;;9633:10;9627:17;9690:15;9677:10;9673:2;9669:19;9662:44;9397:392;9760:17;;;;;;;;;;;;;;7:99:1;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:246::-;368:1;378:113;392:6;389:1;386:13;378:113;;;477:1;472:3;468:11;462:18;458:1;453:3;449:11;442:39;414:2;411:1;407:10;402:15;;378:113;;;525:1;516:6;511:3;507:16;500:27;349:184;287:246;;;:::o;539:102::-;580:6;631:2;627:7;622:2;615:5;611:14;607:28;597:38;;539:102;;;:::o;647:377::-;735:3;763:39;796:5;763:39;:::i;:::-;818:71;882:6;877:3;818:71;:::i;:::-;811:78;;898:65;956:6;951:3;944:4;937:5;933:16;898:65;:::i;:::-;988:29;1010:6;988:29;:::i;:::-;983:3;979:39;972:46;;739:285;647:377;;;;:::o;1030:313::-;1143:4;1181:2;1170:9;1166:18;1158:26;;1230:9;1224:4;1220:20;1216:1;1205:9;1201:17;1194:47;1258:78;1331:4;1322:6;1258:78;:::i;:::-;1250:86;;1030:313;;;;:::o;1430:117::-;1539:1;1536;1529:12;1676:126;1713:7;1753:42;1746:5;1742:54;1731:65;;1676:126;;;:::o;1808:96::-;1845:7;1874:24;1892:5;1874:24;:::i;:::-;1863:35;;1808:96;;;:::o;1910:122::-;1983:24;2001:5;1983:24;:::i;:::-;1976:5;1973:35;1963:63;;2022:1;2019;2012:12;1963:63;1910:122;:::o;2038:139::-;2084:5;2122:6;2109:20;2100:29;;2138:33;2165:5;2138:33;:::i;:::-;2038:139;;;;:::o;2183:77::-;2220:7;2249:5;2238:16;;2183:77;;;:::o;2266:122::-;2339:24;2357:5;2339:24;:::i;:::-;2332:5;2329:35;2319:63;;2378:1;2375;2368:12;2319:63;2266:122;:::o;2394:139::-;2440:5;2478:6;2465:20;2456:29;;2494:33;2521:5;2494:33;:::i;:::-;2394:139;;;;:::o;2539:474::-;2607:6;2615;2664:2;2652:9;2643:7;2639:23;2635:32;2632:119;;;2670:79;;:::i;:::-;2632:119;2790:1;2815:53;2860:7;2851:6;2840:9;2836:22;2815:53;:::i;:::-;2805:63;;2761:117;2917:2;2943:53;2988:7;2979:6;2968:9;2964:22;2943:53;:::i;:::-;2933:63;;2888:118;2539:474;;;;;:::o;3019:90::-;3053:7;3096:5;3089:13;3082:21;3071:32;;3019:90;;;:::o;3115:109::-;3196:21;3211:5;3196:21;:::i;:::-;3191:3;3184:34;3115:109;;:::o;3230:210::-;3317:4;3355:2;3344:9;3340:18;3332:26;;3368:65;3430:1;3419:9;3415:17;3406:6;3368:65;:::i;:::-;3230:210;;;;:::o;3446:118::-;3533:24;3551:5;3533:24;:::i;:::-;3528:3;3521:37;3446:118;;:::o;3570:222::-;3663:4;3701:2;3690:9;3686:18;3678:26;;3714:71;3782:1;3771:9;3767:17;3758:6;3714:71;:::i;:::-;3570:222;;;;:::o;3798:619::-;3875:6;3883;3891;3940:2;3928:9;3919:7;3915:23;3911:32;3908:119;;;3946:79;;:::i;:::-;3908:119;4066:1;4091:53;4136:7;4127:6;4116:9;4112:22;4091:53;:::i;:::-;4081:63;;4037:117;4193:2;4219:53;4264:7;4255:6;4244:9;4240:22;4219:53;:::i;:::-;4209:63;;4164:118;4321:2;4347:53;4392:7;4383:6;4372:9;4368:22;4347:53;:::i;:::-;4337:63;;4292:118;3798:619;;;;;:::o;4423:86::-;4458:7;4498:4;4491:5;4487:16;4476:27;;4423:86;;;:::o;4515:112::-;4598:22;4614:5;4598:22;:::i;:::-;4593:3;4586:35;4515:112;;:::o;4633:214::-;4722:4;4760:2;4749:9;4745:18;4737:26;;4773:67;4837:1;4826:9;4822:17;4813:6;4773:67;:::i;:::-;4633:214;;;;:::o;4853:77::-;4890:7;4919:5;4908:16;;4853:77;;;:::o;4936:118::-;5023:24;5041:5;5023:24;:::i;:::-;5018:3;5011:37;4936:118;;:::o;5060:222::-;5153:4;5191:2;5180:9;5176:18;5168:26;;5204:71;5272:1;5261:9;5257:17;5248:6;5204:71;:::i;:::-;5060:222;;;;:::o;5288:474::-;5356:6;5364;5413:2;5401:9;5392:7;5388:23;5384:32;5381:119;;;5419:79;;:::i;:::-;5381:119;5539:1;5564:53;5609:7;5600:6;5589:9;5585:22;5564:53;:::i;:::-;5554:63;;5510:117;5666:2;5692:53;5737:7;5728:6;5717:9;5713:22;5692:53;:::i;:::-;5682:63;;5637:118;5288:474;;;;;:::o;5768:329::-;5827:6;5876:2;5864:9;5855:7;5851:23;5847:32;5844:119;;;5882:79;;:::i;:::-;5844:119;6002:1;6027:53;6072:7;6063:6;6052:9;6048:22;6027:53;:::i;:::-;6017:63;;5973:117;5768:329;;;;:::o;6103:::-;6162:6;6211:2;6199:9;6190:7;6186:23;6182:32;6179:119;;;6217:79;;:::i;:::-;6179:119;6337:1;6362:53;6407:7;6398:6;6387:9;6383:22;6362:53;:::i;:::-;6352:63;;6308:117;6103:329;;;;:::o;6438:149::-;6474:7;6514:66;6507:5;6503:78;6492:89;;6438:149;;;:::o;6593:115::-;6678:23;6695:5;6678:23;:::i;:::-;6673:3;6666:36;6593:115;;:::o;6714:118::-;6801:24;6819:5;6801:24;:::i;:::-;6796:3;6789:37;6714:118;;:::o;6838:114::-;6905:6;6939:5;6933:12;6923:22;;6838:114;;;:::o;6958:184::-;7057:11;7091:6;7086:3;7079:19;7131:4;7126:3;7122:14;7107:29;;6958:184;;;;:::o;7148:132::-;7215:4;7238:3;7230:11;;7268:4;7263:3;7259:14;7251:22;;7148:132;;;:::o;7286:108::-;7363:24;7381:5;7363:24;:::i;:::-;7358:3;7351:37;7286:108;;:::o;7400:179::-;7469:10;7490:46;7532:3;7524:6;7490:46;:::i;:::-;7568:4;7563:3;7559:14;7545:28;;7400:179;;;;:::o;7585:113::-;7655:4;7687;7682:3;7678:14;7670:22;;7585:113;;;:::o;7734:732::-;7853:3;7882:54;7930:5;7882:54;:::i;:::-;7952:86;8031:6;8026:3;7952:86;:::i;:::-;7945:93;;8062:56;8112:5;8062:56;:::i;:::-;8141:7;8172:1;8157:284;8182:6;8179:1;8176:13;8157:284;;;8258:6;8252:13;8285:63;8344:3;8329:13;8285:63;:::i;:::-;8278:70;;8371:60;8424:6;8371:60;:::i;:::-;8361:70;;8217:224;8204:1;8201;8197:9;8192:14;;8157:284;;;8161:14;8457:3;8450:10;;7858:608;;;7734:732;;;;:::o;8472:1215::-;8821:4;8859:3;8848:9;8844:19;8836:27;;8873:69;8939:1;8928:9;8924:17;8915:6;8873:69;:::i;:::-;8989:9;8983:4;8979:20;8974:2;8963:9;8959:18;8952:48;9017:78;9090:4;9081:6;9017:78;:::i;:::-;9009:86;;9142:9;9136:4;9132:20;9127:2;9116:9;9112:18;9105:48;9170:78;9243:4;9234:6;9170:78;:::i;:::-;9162:86;;9258:72;9326:2;9315:9;9311:18;9302:6;9258:72;:::i;:::-;9340:73;9408:3;9397:9;9393:19;9384:6;9340:73;:::i;:::-;9423;9491:3;9480:9;9476:19;9467:6;9423:73;:::i;:::-;9544:9;9538:4;9534:20;9528:3;9517:9;9513:19;9506:49;9572:108;9675:4;9666:6;9572:108;:::i;:::-;9564:116;;8472:1215;;;;;;;;;;:::o;9693:222::-;9786:4;9824:2;9813:9;9809:18;9801:26;;9837:71;9905:1;9894:9;9890:17;9881:6;9837:71;:::i;:::-;9693:222;;;;:::o;9921:118::-;9992:22;10008:5;9992:22;:::i;:::-;9985:5;9982:33;9972:61;;10029:1;10026;10019:12;9972:61;9921:118;:::o;10045:135::-;10089:5;10127:6;10114:20;10105:29;;10143:31;10168:5;10143:31;:::i;:::-;10045:135;;;;:::o;10186:122::-;10259:24;10277:5;10259:24;:::i;:::-;10252:5;10249:35;10239:63;;10298:1;10295;10288:12;10239:63;10186:122;:::o;10314:139::-;10360:5;10398:6;10385:20;10376:29;;10414:33;10441:5;10414:33;:::i;:::-;10314:139;;;;:::o;10459:1199::-;10570:6;10578;10586;10594;10602;10610;10618;10667:3;10655:9;10646:7;10642:23;10638:33;10635:120;;;10674:79;;:::i;:::-;10635:120;10794:1;10819:53;10864:7;10855:6;10844:9;10840:22;10819:53;:::i;:::-;10809:63;;10765:117;10921:2;10947:53;10992:7;10983:6;10972:9;10968:22;10947:53;:::i;:::-;10937:63;;10892:118;11049:2;11075:53;11120:7;11111:6;11100:9;11096:22;11075:53;:::i;:::-;11065:63;;11020:118;11177:2;11203:53;11248:7;11239:6;11228:9;11224:22;11203:53;:::i;:::-;11193:63;;11148:118;11305:3;11332:51;11375:7;11366:6;11355:9;11351:22;11332:51;:::i;:::-;11322:61;;11276:117;11432:3;11459:53;11504:7;11495:6;11484:9;11480:22;11459:53;:::i;:::-;11449:63;;11403:119;11561:3;11588:53;11633:7;11624:6;11613:9;11609:22;11588:53;:::i;:::-;11578:63;;11532:119;10459:1199;;;;;;;;;;:::o;11664:474::-;11732:6;11740;11789:2;11777:9;11768:7;11764:23;11760:32;11757:119;;;11795:79;;:::i;:::-;11757:119;11915:1;11940:53;11985:7;11976:6;11965:9;11961:22;11940:53;:::i;:::-;11930:63;;11886:117;12042:2;12068:53;12113:7;12104:6;12093:9;12089:22;12068:53;:::i;:::-;12058:63;;12013:118;11664:474;;;;;:::o;12144:180::-;12192:77;12189:1;12182:88;12289:4;12286:1;12279:15;12313:4;12310:1;12303:15;12330:320;12374:6;12411:1;12405:4;12401:12;12391:22;;12458:1;12452:4;12448:12;12479:18;12469:81;;12535:4;12527:6;12523:17;12513:27;;12469:81;12597:2;12589:6;12586:14;12566:18;12563:38;12560:84;;12616:18;;:::i;:::-;12560:84;12381:269;12330:320;;;:::o;12656:172::-;12796:24;12792:1;12784:6;12780:14;12773:48;12656:172;:::o;12834:366::-;12976:3;12997:67;13061:2;13056:3;12997:67;:::i;:::-;12990:74;;13073:93;13162:3;13073:93;:::i;:::-;13191:2;13186:3;13182:12;13175:19;;12834:366;;;:::o;13206:419::-;13372:4;13410:2;13399:9;13395:18;13387:26;;13459:9;13453:4;13449:20;13445:1;13434:9;13430:17;13423:47;13487:131;13613:4;13487:131;:::i;:::-;13479:139;;13206:419;;;:::o;13631:244::-;13771:34;13767:1;13759:6;13755:14;13748:58;13840:27;13835:2;13827:6;13823:15;13816:52;13631:244;:::o;13881:366::-;14023:3;14044:67;14108:2;14103:3;14044:67;:::i;:::-;14037:74;;14120:93;14209:3;14120:93;:::i;:::-;14238:2;14233:3;14229:12;14222:19;;13881:366;;;:::o;14253:419::-;14419:4;14457:2;14446:9;14442:18;14434:26;;14506:9;14500:4;14496:20;14492:1;14481:9;14477:17;14470:47;14534:131;14660:4;14534:131;:::i;:::-;14526:139;;14253:419;;;:::o;14678:176::-;14818:28;14814:1;14806:6;14802:14;14795:52;14678:176;:::o;14860:366::-;15002:3;15023:67;15087:2;15082:3;15023:67;:::i;:::-;15016:74;;15099:93;15188:3;15099:93;:::i;:::-;15217:2;15212:3;15208:12;15201:19;;14860:366;;;:::o;15232:419::-;15398:4;15436:2;15425:9;15421:18;15413:26;;15485:9;15479:4;15475:20;15471:1;15460:9;15456:17;15449:47;15513:131;15639:4;15513:131;:::i;:::-;15505:139;;15232:419;;;:::o;15657:180::-;15705:77;15702:1;15695:88;15802:4;15799:1;15792:15;15826:4;15823:1;15816:15;15843:410;15883:7;15906:20;15924:1;15906:20;:::i;:::-;15901:25;;15940:20;15958:1;15940:20;:::i;:::-;15935:25;;15995:1;15992;15988:9;16017:30;16035:11;16017:30;:::i;:::-;16006:41;;16196:1;16187:7;16183:15;16180:1;16177:22;16157:1;16150:9;16130:83;16107:139;;16226:18;;:::i;:::-;16107:139;15891:362;15843:410;;;;:::o;16259:180::-;16307:77;16304:1;16297:88;16404:4;16401:1;16394:15;16428:4;16425:1;16418:15;16445:185;16485:1;16502:20;16520:1;16502:20;:::i;:::-;16497:25;;16536:20;16554:1;16536:20;:::i;:::-;16531:25;;16575:1;16565:35;;16580:18;;:::i;:::-;16565:35;16622:1;16619;16615:9;16610:14;;16445:185;;;;:::o;16636:180::-;16684:77;16681:1;16674:88;16781:4;16778:1;16771:15;16805:4;16802:1;16795:15;16822:775;17055:4;17093:3;17082:9;17078:19;17070:27;;17107:71;17175:1;17164:9;17160:17;17151:6;17107:71;:::i;:::-;17188:72;17256:2;17245:9;17241:18;17232:6;17188:72;:::i;:::-;17270;17338:2;17327:9;17323:18;17314:6;17270:72;:::i;:::-;17352;17420:2;17409:9;17405:18;17396:6;17352:72;:::i;:::-;17434:73;17502:3;17491:9;17487:19;17478:6;17434:73;:::i;:::-;17517;17585:3;17574:9;17570:19;17561:6;17517:73;:::i;:::-;16822:775;;;;;;;;;:::o;17603:332::-;17724:4;17762:2;17751:9;17747:18;17739:26;;17775:71;17843:1;17832:9;17828:17;17819:6;17775:71;:::i;:::-;17856:72;17924:2;17913:9;17909:18;17900:6;17856:72;:::i;:::-;17603:332;;;;;:::o;17941:442::-;18090:4;18128:2;18117:9;18113:18;18105:26;;18141:71;18209:1;18198:9;18194:17;18185:6;18141:71;:::i;:::-;18222:72;18290:2;18279:9;18275:18;18266:6;18222:72;:::i;:::-;18304;18372:2;18361:9;18357:18;18348:6;18304:72;:::i;:::-;17941:442;;;;;;:::o;18389:::-;18538:4;18576:2;18565:9;18561:18;18553:26;;18589:71;18657:1;18646:9;18642:17;18633:6;18589:71;:::i;:::-;18670:72;18738:2;18727:9;18723:18;18714:6;18670:72;:::i;:::-;18752;18820:2;18809:9;18805:18;18796:6;18752:72;:::i;:::-;18389:442;;;;;;:::o;18837:191::-;18877:3;18896:20;18914:1;18896:20;:::i;:::-;18891:25;;18930:20;18948:1;18930:20;:::i;:::-;18925:25;;18973:1;18970;18966:9;18959:16;;18994:3;18991:1;18988:10;18985:36;;;19001:18;;:::i;:::-;18985:36;18837:191;;;;:::o;19034:332::-;19155:4;19193:2;19182:9;19178:18;19170:26;;19206:71;19274:1;19263:9;19259:17;19250:6;19206:71;:::i;:::-;19287:72;19355:2;19344:9;19340:18;19331:6;19287:72;:::i;:::-;19034:332;;;;;:::o;19372:85::-;19417:7;19446:5;19435:16;;19372:85;;;:::o;19463:60::-;19491:3;19512:5;19505:12;;19463:60;;;:::o;19529:158::-;19587:9;19620:61;19638:42;19647:32;19673:5;19647:32;:::i;:::-;19638:42;:::i;:::-;19620:61;:::i;:::-;19607:74;;19529:158;;;:::o;19693:147::-;19788:45;19827:5;19788:45;:::i;:::-;19783:3;19776:58;19693:147;;:::o;19846:348::-;19975:4;20013:2;20002:9;19998:18;19990:26;;20026:71;20094:1;20083:9;20079:17;20070:6;20026:71;:::i;:::-;20107:80;20183:2;20172:9;20168:18;20159:6;20107:80;:::i;:::-;19846:348;;;;;:::o;20200:180::-;20248:77;20245:1;20238:88;20345:4;20342:1;20335:15;20369:4;20366:1;20359:15;20386:332;20507:4;20545:2;20534:9;20530:18;20522:26;;20558:71;20626:1;20615:9;20611:17;20602:6;20558:71;:::i;:::-;20639:72;20707:2;20696:9;20692:18;20683:6;20639:72;:::i;:::-;20386:332;;;;;:::o;20724:167::-;20761:3;20784:22;20800:5;20784:22;:::i;:::-;20775:31;;20828:4;20821:5;20818:15;20815:41;;20836:18;;:::i;:::-;20815:41;20883:1;20876:5;20872:13;20865:20;;20724:167;;;:::o;20897:664::-;21102:4;21140:3;21129:9;21125:19;21117:27;;21154:71;21222:1;21211:9;21207:17;21198:6;21154:71;:::i;:::-;21235:72;21303:2;21292:9;21288:18;21279:6;21235:72;:::i;:::-;21317;21385:2;21374:9;21370:18;21361:6;21317:72;:::i;:::-;21399;21467:2;21456:9;21452:18;21443:6;21399:72;:::i;:::-;21481:73;21549:3;21538:9;21534:19;21525:6;21481:73;:::i;:::-;20897:664;;;;;;;;:::o;21567:116::-;21637:21;21652:5;21637:21;:::i;:::-;21630:5;21627:32;21617:60;;21673:1;21670;21663:12;21617:60;21567:116;:::o;21689:137::-;21743:5;21774:6;21768:13;21759:22;;21790:30;21814:5;21790:30;:::i;:::-;21689:137;;;;:::o;21832:345::-;21899:6;21948:2;21936:9;21927:7;21923:23;21919:32;21916:119;;;21954:79;;:::i;:::-;21916:119;22074:1;22099:61;22152:7;22143:6;22132:9;22128:22;22099:61;:::i;:::-;22089:71;;22045:125;21832:345;;;;:::o;22183:98::-;22234:6;22268:5;22262:12;22252:22;;22183:98;;;:::o;22287:147::-;22388:11;22425:3;22410:18;;22287:147;;;;:::o;22440:386::-;22544:3;22572:38;22604:5;22572:38;:::i;:::-;22626:88;22707:6;22702:3;22626:88;:::i;:::-;22619:95;;22723:65;22781:6;22776:3;22769:4;22762:5;22758:16;22723:65;:::i;:::-;22813:6;22808:3;22804:16;22797:23;;22548:278;22440:386;;;;:::o;22832:271::-;22962:3;22984:93;23073:3;23064:6;22984:93;:::i;:::-;22977:100;;23094:3;23087:10;;22832:271;;;;:::o;23109:545::-;23282:4;23320:3;23309:9;23305:19;23297:27;;23334:71;23402:1;23391:9;23387:17;23378:6;23334:71;:::i;:::-;23415:68;23479:2;23468:9;23464:18;23455:6;23415:68;:::i;:::-;23493:72;23561:2;23550:9;23546:18;23537:6;23493:72;:::i;:::-;23575;23643:2;23632:9;23628:18;23619:6;23575:72;:::i;:::-;23109:545;;;;;;;:::o;23660:180::-;23708:77;23705:1;23698:88;23805:4;23802:1;23795:15;23829:4;23826:1;23819:15

ipfs://b04515377fb4e3791fa5984ec67a6721127fcbf17d420ce382a665ea50da0806