Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC5267
•    - function eip712Domain()
• library SignedMath
•    - function max(int256 a, int256 b)
•    - function min(int256 a, int256 b)
•    - function average(int256 a, int256 b)
•    - function abs(int256 n)
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• library Counters
•    - function current(Counter storage coun ...
•    - function increment(Counter storage co ...
•    - function decrement(Counter storage co ...
•    - function reset(Counter storage counte ...
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(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 ...
• library Strings
•    - function toString(uint256 value)
•    - function toString(int256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
•    - function equal(string memory a, strin ...
• library ECDSA
•    - function _throwError(RecoverError err ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes3 ...
•    - function tryRecover(bytes32 hash, uin ...
•    - function recover(bytes32 hash, uint8 ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toTypedDataHash(bytes32 doma ...
•    - function toDataWithIntendedValidatorH ...
• 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 ...
•    - function _domainSeparatorV4()
•    - function _buildDomainSeparator()
•    - function _hashTypedDataV4(bytes32 str ...
•    - function eip712Domain()
• library Arrays
•    - function findUpperBound(uint256[] sto ...
•    - function unsafeAccess(address[] stora ...
•    - function unsafeAccess(bytes32[] stora ...
•    - function unsafeAccess(uint256[] stora ...
•    - function _msgSender()
•    - function _msgData()
•    - function paused()
•    - function _requireNotPaused()
•    - function _requirePaused()
•    - function _pause()
•    - function _unpause()
•    - 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 ...
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•  contract ERC20 is Context, IERC20, ...
•    - 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 increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(address from, addr ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _spendAllowance(address owne ...
•    - function _beforeTokenTransfer(address ...
•    - function _afterTokenTransfer(address ...
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
•    - function _useNonce(address owner)
•    - function _snapshot()
•    - function _getCurrentSnapshotId()
•    - function balanceOfAt(address account, ...
•    - function totalSupplyAt(uint256 snapsh ...
•    - function _beforeTokenTransfer(address ...
•    - function _valueAt(uint256 snapshotId, ...
•    - function _updateAccountSnapshot(addre ...
•    - function _updateTotalSupplySnapshot()
•    - function _updateSnapshot(Snapshots st ...
•    - function _lastSnapshotId(uint256[] st ...
•    - function burn(uint256 amount)
•    - function burnFrom(address account, ui ...
•  contract NIHAO is ERC20, ERC20Burn ... *
•    - function snapshot()
•    - function pause()
•    - function unpause()
•    - function mint(address to, uint256 amo ...
•    - function _beforeTokenTransfer(address ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-05-29
*/

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


// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC5267.sol)

pragma solidity ^0.8.0;

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


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

pragma solidity ^0.8.0;

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

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

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

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

// File: @openzeppelin/[email protected]/token/ERC20/extensions/IERC20Permit.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

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


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

pragma solidity ^0.8.0;

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

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

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

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

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

// File: @openzeppelin/[email protected]/utils/math/Math.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // 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.
            require(denominator > prod1, "Math: mulDiv overflow");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Return the log in base 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 + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// File: @openzeppelin/[email protected]/utils/Strings.sol


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

pragma solidity ^0.8.0;



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

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

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(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) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

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

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

// File: @openzeppelin/[email protected]/utils/cryptography/ECDSA.sol


// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;


/**
 * @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,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode 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 {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]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        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);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode 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 {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        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]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        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.
     *
     * _Available since v4.2._
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
        // 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);
        }

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

        return (signer, RecoverError.NoError);
    }

    /**
     * @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) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32")
            mstore(0x1c, hash)
            message := keccak256(0x00, 0x3c)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, "\x19\x01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            data := keccak256(ptr, 0x42)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Data with intended validator, created from a
     * `validator` and `data` according to the version 0 of EIP-191.
     *
     * See {recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x00", validator, data));
    }
}

// File: @openzeppelin/[email protected]/utils/StorageSlot.sol


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

pragma solidity ^0.8.0;

/**
 * @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(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
 * _Available since v4.9 for `string`, `bytes`._
 */
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/[email protected]/utils/ShortStrings.sol


// OpenZeppelin Contracts (last updated v4.9.0) (utils/ShortStrings.sol)

pragma solidity ^0.8.8;


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


// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/EIP712.sol)

pragma solidity ^0.8.8;




/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic 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 their contracts 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.
 *
 * _Available since v3.4._
 *
 * @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
 */
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 ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }

    /**
     * @dev See {EIP-5267}.
     *
     * _Available since v4.9._
     */
    function eip712Domain()
        public
        view
        virtual
        override
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        )
    {
        return (
            hex"0f", // 01111
            _name.toStringWithFallback(_nameFallback),
            _version.toStringWithFallback(_versionFallback),
            block.chainid,
            address(this),
            bytes32(0),
            new uint256[](0)
        );
    }
}

// File: @openzeppelin/[email protected]/utils/Arrays.sol


// OpenZeppelin Contracts (last updated v4.9.0) (utils/Arrays.sol)

pragma solidity ^0.8.0;



/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
    using StorageSlot for bytes32;

    /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        if (array.length == 0) {
            return 0;
        }

        uint256 low = 0;
        uint256 high = array.length;

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds down (it does integer division with truncation).
            if (unsafeAccess(array, mid).value > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && unsafeAccess(array, low - 1).value == element) {
            return low - 1;
        } else {
            return low;
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(address[] storage arr, uint256 pos) internal pure returns (StorageSlot.AddressSlot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.17/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getAddressSlot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(bytes32[] storage arr, uint256 pos) internal pure returns (StorageSlot.Bytes32Slot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.17/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getBytes32Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(uint256[] storage arr, uint256 pos) internal pure returns (StorageSlot.Uint256Slot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.17/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getUint256Slot();
    }
}

// File: @openzeppelin/[email protected]/utils/Context.sol


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

pragma solidity ^0.8.0;

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

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

// File: @openzeppelin/[email protected]/security/Pausable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;


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

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

    bool private _paused;

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

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

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

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

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

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

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

// File: @openzeppelin/[email protected]/access/Ownable.sol


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

pragma solidity ^0.8.0;


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

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

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

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. 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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

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

// File: @openzeppelin/[email protected]/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @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 amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` 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 amount) 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 `amount` 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 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` 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 amount) external returns (bool);
}

// File: @openzeppelin/[email protected]/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
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/[email protected]/token/ERC20/ERC20.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;




/**
 * @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}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * 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.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => 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 override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override 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 override returns (uint8) {
        return 18;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override 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 `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` 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 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        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 `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `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.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` 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.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

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

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

// File: @openzeppelin/[email protected]/token/ERC20/extensions/ERC20Permit.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/ERC20Permit.sol)

pragma solidity ^0.8.0;






/**
 * @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.
 *
 * _Available since v3.4._
 */
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
    using Counters for Counters.Counter;

    mapping(address => Counters.Counter) private _nonces;

    // solhint-disable-next-line var-name-mixedcase
    bytes32 private constant _PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    /**
     * @dev In previous versions `_PERMIT_TYPEHASH` was declared as `immutable`.
     * However, to ensure consistency with the upgradeable transpiler, we will continue
     * to reserve a slot.
     * @custom:oz-renamed-from _PERMIT_TYPEHASH
     */
    // solhint-disable-next-line var-name-mixedcase
    bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;

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

    /**
     * @dev See {IERC20Permit-permit}.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual override {
        require(block.timestamp <= deadline, "ERC20Permit: expired 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);
        require(signer == owner, "ERC20Permit: invalid signature");

        _approve(owner, spender, value);
    }

    /**
     * @dev See {IERC20Permit-nonces}.
     */
    function nonces(address owner) public view virtual override returns (uint256) {
        return _nonces[owner].current();
    }

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

    /**
     * @dev "Consume a nonce": return the current value and increment.
     *
     * _Available since v4.1._
     */
    function _useNonce(address owner) internal virtual returns (uint256 current) {
        Counters.Counter storage nonce = _nonces[owner];
        current = nonce.current();
        nonce.increment();
    }
}

// File: @openzeppelin/[email protected]/token/ERC20/extensions/draft-ERC20Permit.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/draft-ERC20Permit.sol)

pragma solidity ^0.8.0;

// EIP-2612 is Final as of 2022-11-01. This file is deprecated.


// File: @openzeppelin/[email protected]/token/ERC20/extensions/ERC20Snapshot.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/ERC20Snapshot.sol)

pragma solidity ^0.8.0;




/**
 * @dev This contract extends an ERC20 token with a snapshot mechanism. When a snapshot is created, the balances and
 * total supply at the time are recorded for later access.
 *
 * This can be used to safely create mechanisms based on token balances such as trustless dividends or weighted voting.
 * In naive implementations it's possible to perform a "double spend" attack by reusing the same balance from different
 * accounts. By using snapshots to calculate dividends or voting power, those attacks no longer apply. It can also be
 * used to create an efficient ERC20 forking mechanism.
 *
 * Snapshots are created by the internal {_snapshot} function, which will emit the {Snapshot} event and return a
 * snapshot id. To get the total supply at the time of a snapshot, call the function {totalSupplyAt} with the snapshot
 * id. To get the balance of an account at the time of a snapshot, call the {balanceOfAt} function with the snapshot id
 * and the account address.
 *
 * NOTE: Snapshot policy can be customized by overriding the {_getCurrentSnapshotId} method. For example, having it
 * return `block.number` will trigger the creation of snapshot at the beginning of each new block. When overriding this
 * function, be careful about the monotonicity of its result. Non-monotonic snapshot ids will break the contract.
 *
 * Implementing snapshots for every block using this method will incur significant gas costs. For a gas-efficient
 * alternative consider {ERC20Votes}.
 *
 * ==== Gas Costs
 *
 * Snapshots are efficient. Snapshot creation is _O(1)_. Retrieval of balances or total supply from a snapshot is _O(log
 * n)_ in the number of snapshots that have been created, although _n_ for a specific account will generally be much
 * smaller since identical balances in subsequent snapshots are stored as a single entry.
 *
 * There is a constant overhead for normal ERC20 transfers due to the additional snapshot bookkeeping. This overhead is
 * only significant for the first transfer that immediately follows a snapshot for a particular account. Subsequent
 * transfers will have normal cost until the next snapshot, and so on.
 */

abstract contract ERC20Snapshot is ERC20 {
    // Inspired by Jordi Baylina's MiniMeToken to record historical balances:
    // https://github.com/Giveth/minime/blob/ea04d950eea153a04c51fa510b068b9dded390cb/contracts/MiniMeToken.sol

    using Arrays for uint256[];
    using Counters for Counters.Counter;

    // Snapshotted values have arrays of ids and the value corresponding to that id. These could be an array of a
    // Snapshot struct, but that would impede usage of functions that work on an array.
    struct Snapshots {
        uint256[] ids;
        uint256[] values;
    }

    mapping(address => Snapshots) private _accountBalanceSnapshots;
    Snapshots private _totalSupplySnapshots;

    // Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
    Counters.Counter private _currentSnapshotId;

    /**
     * @dev Emitted by {_snapshot} when a snapshot identified by `id` is created.
     */
    event Snapshot(uint256 id);

    /**
     * @dev Creates a new snapshot and returns its snapshot id.
     *
     * Emits a {Snapshot} event that contains the same id.
     *
     * {_snapshot} is `internal` and you have to decide how to expose it externally. Its usage may be restricted to a
     * set of accounts, for example using {AccessControl}, or it may be open to the public.
     *
     * [WARNING]
     * ====
     * While an open way of calling {_snapshot} is required for certain trust minimization mechanisms such as forking,
     * you must consider that it can potentially be used by attackers in two ways.
     *
     * First, it can be used to increase the cost of retrieval of values from snapshots, although it will grow
     * logarithmically thus rendering this attack ineffective in the long term. Second, it can be used to target
     * specific accounts and increase the cost of ERC20 transfers for them, in the ways specified in the Gas Costs
     * section above.
     *
     * We haven't measured the actual numbers; if this is something you're interested in please reach out to us.
     * ====
     */
    function _snapshot() internal virtual returns (uint256) {
        _currentSnapshotId.increment();

        uint256 currentId = _getCurrentSnapshotId();
        emit Snapshot(currentId);
        return currentId;
    }

    /**
     * @dev Get the current snapshotId
     */
    function _getCurrentSnapshotId() internal view virtual returns (uint256) {
        return _currentSnapshotId.current();
    }

    /**
     * @dev Retrieves the balance of `account` at the time `snapshotId` was created.
     */
    function balanceOfAt(address account, uint256 snapshotId) public view virtual returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);

        return snapshotted ? value : balanceOf(account);
    }

    /**
     * @dev Retrieves the total supply at the time `snapshotId` was created.
     */
    function totalSupplyAt(uint256 snapshotId) public view virtual returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots);

        return snapshotted ? value : totalSupply();
    }

    // Update balance and/or total supply snapshots before the values are modified. This is implemented
    // in the _beforeTokenTransfer hook, which is executed for _mint, _burn, and _transfer operations.
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);

        if (from == address(0)) {
            // mint
            _updateAccountSnapshot(to);
            _updateTotalSupplySnapshot();
        } else if (to == address(0)) {
            // burn
            _updateAccountSnapshot(from);
            _updateTotalSupplySnapshot();
        } else {
            // transfer
            _updateAccountSnapshot(from);
            _updateAccountSnapshot(to);
        }
    }

    function _valueAt(uint256 snapshotId, Snapshots storage snapshots) private view returns (bool, uint256) {
        require(snapshotId > 0, "ERC20Snapshot: id is 0");
        require(snapshotId <= _getCurrentSnapshotId(), "ERC20Snapshot: nonexistent id");

        // When a valid snapshot is queried, there are three possibilities:
        //  a) The queried value was not modified after the snapshot was taken. Therefore, a snapshot entry was never
        //  created for this id, and all stored snapshot ids are smaller than the requested one. The value that corresponds
        //  to this id is the current one.
        //  b) The queried value was modified after the snapshot was taken. Therefore, there will be an entry with the
        //  requested id, and its value is the one to return.
        //  c) More snapshots were created after the requested one, and the queried value was later modified. There will be
        //  no entry for the requested id: the value that corresponds to it is that of the smallest snapshot id that is
        //  larger than the requested one.
        //
        // In summary, we need to find an element in an array, returning the index of the smallest value that is larger if
        // it is not found, unless said value doesn't exist (e.g. when all values are smaller). Arrays.findUpperBound does
        // exactly this.

        uint256 index = snapshots.ids.findUpperBound(snapshotId);

        if (index == snapshots.ids.length) {
            return (false, 0);
        } else {
            return (true, snapshots.values[index]);
        }
    }

    function _updateAccountSnapshot(address account) private {
        _updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
    }

    function _updateTotalSupplySnapshot() private {
        _updateSnapshot(_totalSupplySnapshots, totalSupply());
    }

    function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
        uint256 currentId = _getCurrentSnapshotId();
        if (_lastSnapshotId(snapshots.ids) < currentId) {
            snapshots.ids.push(currentId);
            snapshots.values.push(currentValue);
        }
    }

    function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) {
        if (ids.length == 0) {
            return 0;
        } else {
            return ids[ids.length - 1];
        }
    }
}

// File: @openzeppelin/[email protected]/token/ERC20/extensions/ERC20Burnable.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)

pragma solidity ^0.8.0;



/**
 * @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 `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` 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
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        _spendAllowance(account, _msgSender(), amount);
        _burn(account, amount);
    }
}

// File: contract-0f862a1845.sol


pragma solidity ^0.8.9;







/// @custom:security-contact NIHAO.BIO
contract NIHAO is ERC20, ERC20Burnable, ERC20Snapshot, Ownable, Pausable, ERC20Permit {
    constructor() ERC20("NI HAO", "NIHAO") ERC20Permit("NI HAO") {
        _mint(msg.sender, 10000000000 * 10 ** decimals());
    }

    function snapshot() public onlyOwner {
        _snapshot();
    }

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

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

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }

    function _beforeTokenTransfer(address from, address to, uint256 amount)
        internal
        whenNotPaused
        override(ERC20, ERC20Snapshot)
    {
        super._beforeTokenTransfer(from, to, amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidShortString","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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Snapshot","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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":"amount","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":"address","name":"account","type":"address"},{"internalType":"uint256","name":"snapshotId","type":"uint256"}],"name":"balanceOfAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","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":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"snapshot","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":"uint256","name":"snapshotId","type":"uint256"}],"name":"totalSupplyAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","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":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

86652:774:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61889:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64249:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63018:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65030:261;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62860:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75695:115;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65700:238;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;87026:65;;;:::i;:::-;;87099:95;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;85954:91;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;81504:266;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52462:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63189:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55326:103;;;:::i;:::-;;86364:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75437:128;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;86957:61;;;:::i;:::-;;45166:657;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;54685:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62108:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;86882:67;;;:::i;:::-;;81874:234;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66441:436;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63522:193;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74726:645;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;63778:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55584:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;61889:100;61943:13;61976:5;61969:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61889:100;:::o;64249:201::-;64332:4;64349:13;64365:12;:10;:12::i;:::-;64349:28;;64388:32;64397:5;64404:7;64413:6;64388:8;:32::i;:::-;64438:4;64431:11;;;64249:201;;;;:::o;63018:108::-;63079:7;63106:12;;63099:19;;63018:108;:::o;65030:261::-;65127:4;65144:15;65162:12;:10;:12::i;:::-;65144:30;;65185:38;65201:4;65207:7;65216:6;65185:15;:38::i;:::-;65234:27;65244:4;65250:2;65254:6;65234:9;:27::i;:::-;65279:4;65272:11;;;65030:261;;;;;:::o;62860:93::-;62918:5;62943:2;62936:9;;62860:93;:::o;75695:115::-;75755:7;75782:20;:18;:20::i;:::-;75775:27;;75695:115;:::o;65700:238::-;65788:4;65805:13;65821:12;:10;:12::i;:::-;65805:28;;65844:64;65853:5;65860:7;65897:10;65869:25;65879:5;65886:7;65869:9;:25::i;:::-;:38;;;;:::i;:::-;65844:8;:64::i;:::-;65926:4;65919:11;;;65700:238;;;;:::o;87026:65::-;54571:13;:11;:13::i;:::-;87073:10:::1;:8;:10::i;:::-;87026:65::o:0;87099:95::-;54571:13;:11;:13::i;:::-;87169:17:::1;87175:2;87179:6;87169:5;:17::i;:::-;87099:95:::0;;:::o;85954:91::-;86010:27;86016:12;:10;:12::i;:::-;86030:6;86010:5;:27::i;:::-;85954:91;:::o;81504:266::-;81591:7;81612:16;81630:13;81647:55;81656:10;81668:24;:33;81693:7;81668:33;;;;;;;;;;;;;;;81647:8;:55::i;:::-;81611:91;;;;81722:11;:40;;81744:18;81754:7;81744:9;:18::i;:::-;81722:40;;;81736:5;81722:40;81715:47;;;;81504:266;;;;:::o;52462:86::-;52509:4;52533:7;;;;;;;;;;;52526:14;;52462:86;:::o;63189:127::-;63263:7;63290:9;:18;63300:7;63290:18;;;;;;;;;;;;;;;;63283:25;;63189:127;;;:::o;55326:103::-;54571:13;:11;:13::i;:::-;55391:30:::1;55418:1;55391:18;:30::i;:::-;55326:103::o:0;86364:164::-;86441:46;86457:7;86466:12;:10;:12::i;:::-;86480:6;86441:15;:46::i;:::-;86498:22;86504:7;86513:6;86498:5;:22::i;:::-;86364:164;;:::o;75437:128::-;75506:7;75533:24;:7;:14;75541:5;75533:14;;;;;;;;;;;;;;;:22;:24::i;:::-;75526:31;;75437:128;;;:::o;86957:61::-;54571:13;:11;:13::i;:::-;87002:8:::1;:6;:8::i;:::-;86957:61::o:0;45166:657::-;45287:13;45315:18;45348:21;45384:15;45414:25;45454:12;45481:27;45589:41;45616:13;45589:5;:26;;:41;;;;:::i;:::-;45645:47;45675:16;45645:8;:29;;:47;;;;:::i;:::-;45707:13;45743:4;45771:1;45763:10;;45802:1;45788:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45536:279;;;;;;;;;;;;;;;;;;;;;45166:657;;;;;;;:::o;54685:87::-;54731:7;54758:6;;;;;;;;;;;54751:13;;54685:87;:::o;62108:104::-;62164:13;62197:7;62190:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62108:104;:::o;86882:67::-;54571:13;:11;:13::i;:::-;86930:11:::1;:9;:11::i;:::-;;86882:67::o:0;81874:234::-;81946:7;81967:16;81985:13;82002:43;82011:10;82023:21;82002:8;:43::i;:::-;81966:79;;;;82065:11;:35;;82087:13;:11;:13::i;:::-;82065:35;;;82079:5;82065:35;82058:42;;;;81874:234;;;:::o;66441:436::-;66534:4;66551:13;66567:12;:10;:12::i;:::-;66551:28;;66590:24;66617:25;66627:5;66634:7;66617:9;:25::i;:::-;66590:52;;66681:15;66661:16;:35;;66653:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;66774:60;66783:5;66790:7;66818:15;66799:16;:34;66774:8;:60::i;:::-;66865:4;66858:11;;;;66441:436;;;;:::o;63522:193::-;63601:4;63618:13;63634:12;:10;:12::i;:::-;63618:28;;63657;63667:5;63674:2;63678:6;63657:9;:28::i;:::-;63703:4;63696:11;;;63522:193;;;;:::o;74726:645::-;74970:8;74951:15;:27;;74943:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;75025:18;73901:95;75085:5;75092:7;75101:5;75108:16;75118:5;75108:9;:16::i;:::-;75126:8;75056:79;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;75046:90;;;;;;75025:111;;75149:12;75164:28;75181:10;75164:16;:28::i;:::-;75149:43;;75205:14;75222:28;75236:4;75242:1;75245;75248;75222:13;:28::i;:::-;75205:45;;75279:5;75269:15;;:6;:15;;;75261:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;75332:31;75341:5;75348:7;75357:5;75332:8;:31::i;:::-;74932:439;;;74726:645;;;;;;;:::o;63778:151::-;63867:7;63894:11;:18;63906:5;63894:18;;;;;;;;;;;;;;;:27;63913:7;63894:27;;;;;;;;;;;;;;;;63887:34;;63778:151;;;;:::o;55584:201::-;54571:13;:11;:13::i;:::-;55693:1:::1;55673:22;;:8;:22;;::::0;55665:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;55749:28;55768:8;55749:18;:28::i;:::-;55584:201:::0;:::o;38652:348::-;38748:11;38798:2;38782:5;38776:19;:24;38772:221;;;38824:20;38838:5;38824:13;:20::i;:::-;38817:27;;;;38772:221;38918:5;38877:32;38903:5;38877:25;:32::i;:::-;:38;;:46;;;;;;:::i;:::-;;37081:66;38962:18;;38938:43;;38652:348;;;;;:::o;34839:207::-;34907:20;35018:10;35008:20;;34839:207;;;:::o;82325:588::-;82434:44;82461:4;82467:2;82471:6;82434:26;:44::i;:::-;82511:1;82495:18;;:4;:18;;;82491:415;;82551:26;82574:2;82551:22;:26::i;:::-;82592:28;:26;:28::i;:::-;82491:415;;;82656:1;82642:16;;:2;:16;;;82638:268;;82696:28;82719:4;82696:22;:28::i;:::-;82739;:26;:28::i;:::-;82638:268;;;82825:28;82848:4;82825:22;:28::i;:::-;82868:26;82891:2;82868:22;:26::i;:::-;82638:268;82491:415;82325:588;;;:::o;72090:91::-;;;;:::o;5433:114::-;5498:7;5525;:14;;;5518:21;;5433:114;;;:::o;50569:98::-;50622:7;50649:10;50642:17;;50569:98;:::o;70434:346::-;70553:1;70536:19;;:5;:19;;;70528:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70634:1;70615:21;;:7;:21;;;70607:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70718:6;70688:11;:18;70700:5;70688:18;;;;;;;;;;;;;;;:27;70707:7;70688:27;;;;;;;;;;;;;;;:36;;;;70756:7;70740:32;;70749:5;70740:32;;;70765:6;70740:32;;;;;;:::i;:::-;;;;;;;;70434:346;;;:::o;71071:419::-;71172:24;71199:25;71209:5;71216:7;71199:9;:25::i;:::-;71172:52;;71259:17;71239:16;:37;71235:248;;71321:6;71301:16;:26;;71293:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;71405:51;71414:5;71421:7;71449:6;71430:16;:25;71405:8;:51::i;:::-;71235:248;71161:329;71071:419;;;:::o;67347:806::-;67460:1;67444:18;;:4;:18;;;67436:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;67537:1;67523:16;;:2;:16;;;67515:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;67592:38;67613:4;67619:2;67623:6;67592:20;:38::i;:::-;67643:19;67665:9;:15;67675:4;67665:15;;;;;;;;;;;;;;;;67643:37;;67714:6;67699:11;:21;;67691:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;67831:6;67817:11;:20;67799:9;:15;67809:4;67799:15;;;;;;;;;;;;;;;:38;;;;68034:6;68017:9;:13;68027:2;68017:13;;;;;;;;;;;;;;;;:23;;;;;;;;;;;68084:2;68069:26;;68078:4;68069:26;;;68088:6;68069:26;;;;;;:::i;:::-;;;;;;;;68108:37;68128:4;68134:2;68138:6;68108:19;:37::i;:::-;67425:728;67347:806;;;:::o;43804:268::-;43857:7;43898:11;43881:28;;43889:4;43881:28;;;:63;;;;;43930:14;43913:13;:31;43881:63;43877:188;;;43968:22;43961:29;;;;43877:188;44030:23;:21;:23::i;:::-;44023:30;;43804:268;;:::o;54850:132::-;54925:12;:10;:12::i;:::-;54914:23;;:7;:5;:7::i;:::-;:23;;;54906:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;54850:132::o;53317:120::-;52326:16;:14;:16::i;:::-;53386:5:::1;53376:7;;:15;;;;;;;;;;;;;;;;;;53407:22;53416:12;:10;:12::i;:::-;53407:22;;;;;;:::i;:::-;;;;;;;;53317:120::o:0;68440:548::-;68543:1;68524:21;;:7;:21;;;68516:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;68594:49;68623:1;68627:7;68636:6;68594:20;:49::i;:::-;68672:6;68656:12;;:22;;;;;;;:::i;:::-;;;;;;;;68849:6;68827:9;:18;68837:7;68827:18;;;;;;;;;;;;;;;;:28;;;;;;;;;;;68903:7;68882:37;;68899:1;68882:37;;;68912:6;68882:37;;;;;;:::i;:::-;;;;;;;;68932:48;68960:1;68964:7;68973:6;68932:19;:48::i;:::-;68440:548;;:::o;69321:675::-;69424:1;69405:21;;:7;:21;;;69397:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;69477:49;69498:7;69515:1;69519:6;69477:20;:49::i;:::-;69539:22;69564:9;:18;69574:7;69564:18;;;;;;;;;;;;;;;;69539:43;;69619:6;69601:14;:24;;69593:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;69738:6;69721:14;:23;69700:9;:18;69710:7;69700:18;;;;;;;;;;;;;;;:44;;;;69855:6;69839:12;;:22;;;;;;;;;;;69916:1;69890:37;;69899:7;69890:37;;;69920:6;69890:37;;;;;;:::i;:::-;;;;;;;;69940:48;69960:7;69977:1;69981:6;69940:19;:48::i;:::-;69386:610;69321:675;;:::o;82921:1619::-;83010:4;83016:7;83057:1;83044:10;:14;83036:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;83118:23;:21;:23::i;:::-;83104:10;:37;;83096:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;84314:13;84330:40;84359:10;84330:9;:13;;:28;;:40;;;;:::i;:::-;84314:56;;84396:9;:13;;:20;;;;84387:5;:29;84383:150;;84441:5;84448:1;84433:17;;;;;;;84383:150;84491:4;84497:9;:16;;84514:5;84497:23;;;;;;;;:::i;:::-;;;;;;;;;;84483:38;;;;;82921:1619;;;;;;:::o;55945:191::-;56019:16;56038:6;;;;;;;;;;;56019:25;;56064:8;56055:6;;:17;;;;;;;;;;;;;;;;;;56119:8;56088:40;;56109:8;56088:40;;;;;;;;;;;;56008:128;55945:191;:::o;53058:118::-;52067:19;:17;:19::i;:::-;53128:4:::1;53118:7;;:14;;;;;;;;;;;;;;;;;;53148:20;53155:12;:10;:12::i;:::-;53148:20;;;;;;:::i;:::-;;;;;;;;53058:118::o:0;39136:274::-;39230:13;37081:66;39289:18;;39279:5;39260:47;39256:147;;39331:15;39340:5;39331:8;:15::i;:::-;39324:22;;;;39256:147;39386:5;39379:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39136:274;;;;;:::o;80976:223::-;81023:7;81043:30;:18;:28;:30::i;:::-;81086:17;81106:23;:21;:23::i;:::-;81086:43;;81145:19;81154:9;81145:19;;;;;;:::i;:::-;;;;;;;;81182:9;81175:16;;;80976:223;:::o;75948:207::-;76008:15;76036:30;76069:7;:14;76077:5;76069:14;;;;;;;;;;;;;;;76036:47;;76104:15;:5;:13;:15::i;:::-;76094:25;;76130:17;:5;:15;:17::i;:::-;76025:130;75948:207;;;:::o;44904:167::-;44981:7;45008:55;45030:20;:18;:20::i;:::-;45052:10;45008:21;:55::i;:::-;45001:62;;44904:167;;;:::o;28783:236::-;28868:7;28889:17;28908:18;28930:25;28941:4;28947:1;28950;28953;28930:10;:25::i;:::-;28888:67;;;;28966:18;28978:5;28966:11;:18::i;:::-;29002:9;28995:16;;;;28783:236;;;;;;:::o;37409:292::-;37474:11;37498:17;37524:3;37498:30;;37557:2;37543:4;:11;:16;37539:74;;;37597:3;37583:18;;;;;;;;;;;:::i;:::-;;;;;;;;37539:74;37680:4;:11;37671:4;37663:13;;;:::i;:::-;37655:22;;:36;37647:45;;37623:70;;;37409:292;;;:::o;84548:146::-;84616:70;84632:24;:33;84657:7;84632:33;;;;;;;;;;;;;;;84667:18;84677:7;84667:9;:18::i;:::-;84616:15;:70::i;:::-;84548:146;:::o;84702:118::-;84759:53;84775:21;84798:13;:11;:13::i;:::-;84759:15;:53::i;:::-;84702:118::o;87202:221::-;52067:19;:17;:19::i;:::-;87371:44:::1;87398:4;87404:2;87408:6;87371:26;:44::i;:::-;87202:221:::0;;;:::o;72785:90::-;;;;:::o;44080:182::-;44135:7;41996:95;44195:11;44208:14;44224:13;44247:4;44172:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;44162:92;;;;;;44155:99;;44080:182;:::o;52806:108::-;52873:8;:6;:8::i;:::-;52865:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;52806:108::o;81265:127::-;81329:7;81356:28;:18;:26;:28::i;:::-;81349:35;;81265:127;:::o;46540:958::-;46629:7;46669:1;46653:5;:12;;;;:17;46649:58;;46694:1;46687:8;;;;46649:58;46719:11;46745:12;46760:5;:12;;;;46745:27;;46785:444;46798:4;46792:3;:10;46785:444;;;46819:11;46833:23;46846:3;46851:4;46833:12;:23::i;:::-;46819:37;;47110:7;47077:24;47090:5;47097:3;47077:12;:24::i;:::-;:30;;;:40;47073:145;;;47145:3;47138:10;;47073:145;;;47201:1;47195:3;:7;;;;:::i;:::-;47189:13;;47073:145;46804:425;46785:444;;;47355:1;47349:3;:7;:56;;;;;47398:7;47360:28;47373:5;47386:1;47380:3;:7;;;;:::i;:::-;47360:12;:28::i;:::-;:34;;;:45;47349:56;47345:146;;;47435:1;47429:3;:7;;;;:::i;:::-;47422:14;;;;;;47345:146;47476:3;47469:10;;;;46540:958;;;;;:::o;52621:108::-;52692:8;:6;:8::i;:::-;52691:9;52683:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;52621:108::o;37790:415::-;37849:13;37875:11;37889:16;37900:4;37889:10;:16::i;:::-;37875:30;;37995:17;38026:2;38015:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37995:34;;38120:3;38115;38108:16;38161:4;38154;38149:3;38145:14;38138:28;38194:3;38187:10;;;;37790:415;;;:::o;5555:127::-;5662:1;5644:7;:14;;;:19;;;;;;;;;;;5555:127;:::o;30567:406::-;30660:12;30770:4;30764:11;30801:10;30796:3;30789:23;30849:15;30842:4;30837:3;30833:14;30826:39;30902:10;30895:4;30890:3;30886:14;30879:34;30950:4;30945:3;30935:20;30927:28;;30738:228;30567:406;;;;:::o;27167:1477::-;27255:7;27264:12;28189:66;28184:1;28176:10;;:79;28172:163;;;28288:1;28292:30;28272:51;;;;;;28172:163;28432:14;28449:24;28459:4;28465:1;28468;28471;28449:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28432:41;;28506:1;28488:20;;:6;:20;;;28484:103;;28541:1;28545:29;28525:50;;;;;;;28484:103;28607:6;28615:20;28599:37;;;;;27167:1477;;;;;;;;:::o;22627:521::-;22705:20;22696:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;22692:449;22742:7;22692:449;22803:29;22794:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;22790:351;;22849:34;;;;;;;;;;:::i;:::-;;;;;;;;22790:351;22914:35;22905:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;22901:240;;22966:41;;;;;;;;;;:::i;:::-;;;;;;;;22901:240;23038:30;23029:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;23025:116;;23085:44;;;;;;;;;;:::i;:::-;;;;;;;;23025:116;22627:521;;:::o;84828:310::-;84923:17;84943:23;:21;:23::i;:::-;84923:43;;85014:9;84981:30;84997:9;:13;;84981:15;:30::i;:::-;:42;84977:154;;;85040:9;:13;;85059:9;85040:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85084:9;:16;;85106:12;85084:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;84977:154;84912:226;84828:310;;:::o;6895:156::-;6957:7;7042:1;7037;7033;:5;7032:11;;;;:::i;:::-;7027:1;7023;:5;7022:21;;;;:::i;:::-;7015:28;;6895:156;;;;:::o;49293:584::-;49374:31;49418:12;49761:8;49758:1;49751:19;49816:3;49809:4;49806:1;49796:18;49792:28;49784:36;;49848:21;:4;:19;:21::i;:::-;49841:28;;;49293:584;;;;:::o;38282:251::-;38343:7;38363:14;38416:4;38407;38380:33;;:40;38363:57;;38444:2;38435:6;:11;38431:71;;;38470:20;;;;;;;;;;;;;;38431:71;38519:6;38512:13;;;38282:251;;;:::o;85146:212::-;85216:7;85254:1;85240:3;:10;;;;:15;85236:115;;85279:1;85272:8;;;;85236:115;85320:3;85337:1;85324:3;:10;;;;:14;;;;:::i;:::-;85320:19;;;;;;;;:::i;:::-;;;;;;;;;;85313:26;;85146:212;;;;:::o;34232:195::-;34293:21;34405:4;34395:14;;34232:195;;;:::o;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:329::-;5347:6;5396:2;5384:9;5375:7;5371:23;5367:32;5364:119;;;5402:79;;:::i;:::-;5364:119;5522:1;5547:53;5592:7;5583:6;5572:9;5568:22;5547:53;:::i;:::-;5537:63;;5493:117;5288:329;;;;:::o;5623:::-;5682:6;5731:2;5719:9;5710:7;5706:23;5702:32;5699:119;;;5737:79;;:::i;:::-;5699:119;5857:1;5882:53;5927:7;5918:6;5907:9;5903:22;5882:53;:::i;:::-;5872:63;;5828:117;5623:329;;;;:::o;5958:149::-;5994:7;6034:66;6027:5;6023:78;6012:89;;5958:149;;;:::o;6113:115::-;6198:23;6215:5;6198:23;:::i;:::-;6193:3;6186:36;6113:115;;:::o;6234:118::-;6321:24;6339:5;6321:24;:::i;:::-;6316:3;6309:37;6234:118;;:::o;6358:114::-;6425:6;6459:5;6453:12;6443:22;;6358:114;;;:::o;6478:184::-;6577:11;6611:6;6606:3;6599:19;6651:4;6646:3;6642:14;6627:29;;6478:184;;;;:::o;6668:132::-;6735:4;6758:3;6750:11;;6788:4;6783:3;6779:14;6771:22;;6668:132;;;:::o;6806:108::-;6883:24;6901:5;6883:24;:::i;:::-;6878:3;6871:37;6806:108;;:::o;6920:179::-;6989:10;7010:46;7052:3;7044:6;7010:46;:::i;:::-;7088:4;7083:3;7079:14;7065:28;;6920:179;;;;:::o;7105:113::-;7175:4;7207;7202:3;7198:14;7190:22;;7105:113;;;:::o;7254:732::-;7373:3;7402:54;7450:5;7402:54;:::i;:::-;7472:86;7551:6;7546:3;7472:86;:::i;:::-;7465:93;;7582:56;7632:5;7582:56;:::i;:::-;7661:7;7692:1;7677:284;7702:6;7699:1;7696:13;7677:284;;;7778:6;7772:13;7805:63;7864:3;7849:13;7805:63;:::i;:::-;7798:70;;7891:60;7944:6;7891:60;:::i;:::-;7881:70;;7737:224;7724:1;7721;7717:9;7712:14;;7677:284;;;7681:14;7977:3;7970:10;;7378:608;;;7254:732;;;;:::o;7992:1215::-;8341:4;8379:3;8368:9;8364:19;8356:27;;8393:69;8459:1;8448:9;8444:17;8435:6;8393:69;:::i;:::-;8509:9;8503:4;8499:20;8494:2;8483:9;8479:18;8472:48;8537:78;8610:4;8601:6;8537:78;:::i;:::-;8529:86;;8662:9;8656:4;8652:20;8647:2;8636:9;8632:18;8625:48;8690:78;8763:4;8754:6;8690:78;:::i;:::-;8682:86;;8778:72;8846:2;8835:9;8831:18;8822:6;8778:72;:::i;:::-;8860:73;8928:3;8917:9;8913:19;8904:6;8860:73;:::i;:::-;8943;9011:3;9000:9;8996:19;8987:6;8943:73;:::i;:::-;9064:9;9058:4;9054:20;9048:3;9037:9;9033:19;9026:49;9092:108;9195:4;9186:6;9092:108;:::i;:::-;9084:116;;7992:1215;;;;;;;;;;:::o;9213:222::-;9306:4;9344:2;9333:9;9329:18;9321:26;;9357:71;9425:1;9414:9;9410:17;9401:6;9357:71;:::i;:::-;9213:222;;;;:::o;9441:118::-;9512:22;9528:5;9512:22;:::i;:::-;9505:5;9502:33;9492:61;;9549:1;9546;9539:12;9492:61;9441:118;:::o;9565:135::-;9609:5;9647:6;9634:20;9625:29;;9663:31;9688:5;9663:31;:::i;:::-;9565:135;;;;:::o;9706:122::-;9779:24;9797:5;9779:24;:::i;:::-;9772:5;9769:35;9759:63;;9818:1;9815;9808:12;9759:63;9706:122;:::o;9834:139::-;9880:5;9918:6;9905:20;9896:29;;9934:33;9961:5;9934:33;:::i;:::-;9834:139;;;;:::o;9979:1199::-;10090:6;10098;10106;10114;10122;10130;10138;10187:3;10175:9;10166:7;10162:23;10158:33;10155:120;;;10194:79;;:::i;:::-;10155:120;10314:1;10339:53;10384:7;10375:6;10364:9;10360:22;10339:53;:::i;:::-;10329:63;;10285:117;10441:2;10467:53;10512:7;10503:6;10492:9;10488:22;10467:53;:::i;:::-;10457:63;;10412:118;10569:2;10595:53;10640:7;10631:6;10620:9;10616:22;10595:53;:::i;:::-;10585:63;;10540:118;10697:2;10723:53;10768:7;10759:6;10748:9;10744:22;10723:53;:::i;:::-;10713:63;;10668:118;10825:3;10852:51;10895:7;10886:6;10875:9;10871:22;10852:51;:::i;:::-;10842:61;;10796:117;10952:3;10979:53;11024:7;11015:6;11004:9;11000:22;10979:53;:::i;:::-;10969:63;;10923:119;11081:3;11108:53;11153:7;11144:6;11133:9;11129:22;11108:53;:::i;:::-;11098:63;;11052:119;9979:1199;;;;;;;;;;:::o;11184:474::-;11252:6;11260;11309:2;11297:9;11288:7;11284:23;11280:32;11277:119;;;11315:79;;:::i;:::-;11277:119;11435:1;11460:53;11505:7;11496:6;11485:9;11481:22;11460:53;:::i;:::-;11450:63;;11406:117;11562:2;11588:53;11633:7;11624:6;11613:9;11609:22;11588:53;:::i;:::-;11578:63;;11533:118;11184:474;;;;;:::o;11664:180::-;11712:77;11709:1;11702:88;11809:4;11806:1;11799:15;11833:4;11830:1;11823:15;11850:320;11894:6;11931:1;11925:4;11921:12;11911:22;;11978:1;11972:4;11968:12;11999:18;11989:81;;12055:4;12047:6;12043:17;12033:27;;11989:81;12117:2;12109:6;12106:14;12086:18;12083:38;12080:84;;12136:18;;:::i;:::-;12080:84;11901:269;11850:320;;;:::o;12176:180::-;12224:77;12221:1;12214:88;12321:4;12318:1;12311:15;12345:4;12342:1;12335:15;12362:191;12402:3;12421:20;12439:1;12421:20;:::i;:::-;12416:25;;12455:20;12473:1;12455:20;:::i;:::-;12450:25;;12498:1;12495;12491:9;12484:16;;12519:3;12516:1;12513:10;12510:36;;;12526:18;;:::i;:::-;12510:36;12362:191;;;;:::o;12559:180::-;12607:77;12604:1;12597:88;12704:4;12701:1;12694:15;12728:4;12725:1;12718:15;12745:224;12885:34;12881:1;12873:6;12869:14;12862:58;12954:7;12949:2;12941:6;12937:15;12930:32;12745:224;:::o;12975:366::-;13117:3;13138:67;13202:2;13197:3;13138:67;:::i;:::-;13131:74;;13214:93;13303:3;13214:93;:::i;:::-;13332:2;13327:3;13323:12;13316:19;;12975:366;;;:::o;13347:419::-;13513:4;13551:2;13540:9;13536:18;13528:26;;13600:9;13594:4;13590:20;13586:1;13575:9;13571:17;13564:47;13628:131;13754:4;13628:131;:::i;:::-;13620:139;;13347:419;;;:::o;13772:179::-;13912:31;13908:1;13900:6;13896:14;13889:55;13772:179;:::o;13957:366::-;14099:3;14120:67;14184:2;14179:3;14120:67;:::i;:::-;14113:74;;14196:93;14285:3;14196:93;:::i;:::-;14314:2;14309:3;14305:12;14298:19;;13957:366;;;:::o;14329:419::-;14495:4;14533:2;14522:9;14518:18;14510:26;;14582:9;14576:4;14572:20;14568:1;14557:9;14553:17;14546:47;14610:131;14736:4;14610:131;:::i;:::-;14602:139;;14329:419;;;:::o;14754:775::-;14987:4;15025:3;15014:9;15010:19;15002:27;;15039:71;15107:1;15096:9;15092:17;15083:6;15039:71;:::i;:::-;15120:72;15188:2;15177:9;15173:18;15164:6;15120:72;:::i;:::-;15202;15270:2;15259:9;15255:18;15246:6;15202:72;:::i;:::-;15284;15352:2;15341:9;15337:18;15328:6;15284:72;:::i;:::-;15366:73;15434:3;15423:9;15419:19;15410:6;15366:73;:::i;:::-;15449;15517:3;15506:9;15502:19;15493:6;15449:73;:::i;:::-;14754:775;;;;;;;;;:::o;15535:180::-;15675:32;15671:1;15663:6;15659:14;15652:56;15535:180;:::o;15721:366::-;15863:3;15884:67;15948:2;15943:3;15884:67;:::i;:::-;15877:74;;15960:93;16049:3;15960:93;:::i;:::-;16078:2;16073:3;16069:12;16062:19;;15721:366;;;:::o;16093:419::-;16259:4;16297:2;16286:9;16282:18;16274:26;;16346:9;16340:4;16336:20;16332:1;16321:9;16317:17;16310:47;16374:131;16500:4;16374:131;:::i;:::-;16366:139;;16093:419;;;:::o;16518:225::-;16658:34;16654:1;16646:6;16642:14;16635:58;16727:8;16722:2;16714:6;16710:15;16703:33;16518:225;:::o;16749:366::-;16891:3;16912:67;16976:2;16971:3;16912:67;:::i;:::-;16905:74;;16988:93;17077:3;16988:93;:::i;:::-;17106:2;17101:3;17097:12;17090:19;;16749:366;;;:::o;17121:419::-;17287:4;17325:2;17314:9;17310:18;17302:26;;17374:9;17368:4;17364:20;17360:1;17349:9;17345:17;17338:47;17402:131;17528:4;17402:131;:::i;:::-;17394:139;;17121:419;;;:::o;17546:141::-;17595:4;17618:3;17610:11;;17641:3;17638:1;17631:14;17675:4;17672:1;17662:18;17654:26;;17546:141;;;:::o;17693:93::-;17730:6;17777:2;17772;17765:5;17761:14;17757:23;17747:33;;17693:93;;;:::o;17792:107::-;17836:8;17886:5;17880:4;17876:16;17855:37;;17792:107;;;;:::o;17905:393::-;17974:6;18024:1;18012:10;18008:18;18047:97;18077:66;18066:9;18047:97;:::i;:::-;18165:39;18195:8;18184:9;18165:39;:::i;:::-;18153:51;;18237:4;18233:9;18226:5;18222:21;18213:30;;18286:4;18276:8;18272:19;18265:5;18262:30;18252:40;;17981:317;;17905:393;;;;;:::o;18304:60::-;18332:3;18353:5;18346:12;;18304:60;;;:::o;18370:142::-;18420:9;18453:53;18471:34;18480:24;18498:5;18480:24;:::i;:::-;18471:34;:::i;:::-;18453:53;:::i;:::-;18440:66;;18370:142;;;:::o;18518:75::-;18561:3;18582:5;18575:12;;18518:75;;;:::o;18599:269::-;18709:39;18740:7;18709:39;:::i;:::-;18770:91;18819:41;18843:16;18819:41;:::i;:::-;18811:6;18804:4;18798:11;18770:91;:::i;:::-;18764:4;18757:105;18675:193;18599:269;;;:::o;18874:73::-;18919:3;18874:73;:::o;18953:189::-;19030:32;;:::i;:::-;19071:65;19129:6;19121;19115:4;19071:65;:::i;:::-;19006:136;18953:189;;:::o;19148:186::-;19208:120;19225:3;19218:5;19215:14;19208:120;;;19279:39;19316:1;19309:5;19279:39;:::i;:::-;19252:1;19245:5;19241:13;19232:22;;19208:120;;;19148:186;;:::o;19340:543::-;19441:2;19436:3;19433:11;19430:446;;;19475:38;19507:5;19475:38;:::i;:::-;19559:29;19577:10;19559:29;:::i;:::-;19549:8;19545:44;19742:2;19730:10;19727:18;19724:49;;;19763:8;19748:23;;19724:49;19786:80;19842:22;19860:3;19842:22;:::i;:::-;19832:8;19828:37;19815:11;19786:80;:::i;:::-;19445:431;;19430:446;19340:543;;;:::o;19889:117::-;19943:8;19993:5;19987:4;19983:16;19962:37;;19889:117;;;;:::o;20012:169::-;20056:6;20089:51;20137:1;20133:6;20125:5;20122:1;20118:13;20089:51;:::i;:::-;20085:56;20170:4;20164;20160:15;20150:25;;20063:118;20012:169;;;;:::o;20186:295::-;20262:4;20408:29;20433:3;20427:4;20408:29;:::i;:::-;20400:37;;20470:3;20467:1;20463:11;20457:4;20454:21;20446:29;;20186:295;;;;:::o;20486:1395::-;20603:37;20636:3;20603:37;:::i;:::-;20705:18;20697:6;20694:30;20691:56;;;20727:18;;:::i;:::-;20691:56;20771:38;20803:4;20797:11;20771:38;:::i;:::-;20856:67;20916:6;20908;20902:4;20856:67;:::i;:::-;20950:1;20974:4;20961:17;;21006:2;20998:6;20995:14;21023:1;21018:618;;;;21680:1;21697:6;21694:77;;;21746:9;21741:3;21737:19;21731:26;21722:35;;21694:77;21797:67;21857:6;21850:5;21797:67;:::i;:::-;21791:4;21784:81;21653:222;20988:887;;21018:618;21070:4;21066:9;21058:6;21054:22;21104:37;21136:4;21104:37;:::i;:::-;21163:1;21177:208;21191:7;21188:1;21185:14;21177:208;;;21270:9;21265:3;21261:19;21255:26;21247:6;21240:42;21321:1;21313:6;21309:14;21299:24;;21368:2;21357:9;21353:18;21340:31;;21214:4;21211:1;21207:12;21202:17;;21177:208;;;21413:6;21404:7;21401:19;21398:179;;;21471:9;21466:3;21462:19;21456:26;21514:48;21556:4;21548:6;21544:17;21533:9;21514:48;:::i;:::-;21506:6;21499:64;21421:156;21398:179;21623:1;21619;21611:6;21607:14;21603:22;21597:4;21590:36;21025:611;;;20988:887;;20578:1303;;;20486:1395;;:::o;21887:223::-;22027:34;22023:1;22015:6;22011:14;22004:58;22096:6;22091:2;22083:6;22079:15;22072:31;21887:223;:::o;22116:366::-;22258:3;22279:67;22343:2;22338:3;22279:67;:::i;:::-;22272:74;;22355:93;22444:3;22355:93;:::i;:::-;22473:2;22468:3;22464:12;22457:19;;22116:366;;;:::o;22488:419::-;22654:4;22692:2;22681:9;22677:18;22669:26;;22741:9;22735:4;22731:20;22727:1;22716:9;22712:17;22705:47;22769:131;22895:4;22769:131;:::i;:::-;22761:139;;22488:419;;;:::o;22913:221::-;23053:34;23049:1;23041:6;23037:14;23030:58;23122:4;23117:2;23109:6;23105:15;23098:29;22913:221;:::o;23140:366::-;23282:3;23303:67;23367:2;23362:3;23303:67;:::i;:::-;23296:74;;23379:93;23468:3;23379:93;:::i;:::-;23497:2;23492:3;23488:12;23481:19;;23140:366;;;:::o;23512:419::-;23678:4;23716:2;23705:9;23701:18;23693:26;;23765:9;23759:4;23755:20;23751:1;23740:9;23736:17;23729:47;23793:131;23919:4;23793:131;:::i;:::-;23785:139;;23512:419;;;:::o;23937:179::-;24077:31;24073:1;24065:6;24061:14;24054:55;23937:179;:::o;24122:366::-;24264:3;24285:67;24349:2;24344:3;24285:67;:::i;:::-;24278:74;;24361:93;24450:3;24361:93;:::i;:::-;24479:2;24474:3;24470:12;24463:19;;24122:366;;;:::o;24494:419::-;24660:4;24698:2;24687:9;24683:18;24675:26;;24747:9;24741:4;24737:20;24733:1;24722:9;24718:17;24711:47;24775:131;24901:4;24775:131;:::i;:::-;24767:139;;24494:419;;;:::o;24919:224::-;25059:34;25055:1;25047:6;25043:14;25036:58;25128:7;25123:2;25115:6;25111:15;25104:32;24919:224;:::o;25149:366::-;25291:3;25312:67;25376:2;25371:3;25312:67;:::i;:::-;25305:74;;25388:93;25477:3;25388:93;:::i;:::-;25506:2;25501:3;25497:12;25490:19;;25149:366;;;:::o;25521:419::-;25687:4;25725:2;25714:9;25710:18;25702:26;;25774:9;25768:4;25764:20;25760:1;25749:9;25745:17;25738:47;25802:131;25928:4;25802:131;:::i;:::-;25794:139;;25521:419;;;:::o;25946:222::-;26086:34;26082:1;26074:6;26070:14;26063:58;26155:5;26150:2;26142:6;26138:15;26131:30;25946:222;:::o;26174:366::-;26316:3;26337:67;26401:2;26396:3;26337:67;:::i;:::-;26330:74;;26413:93;26502:3;26413:93;:::i;:::-;26531:2;26526:3;26522:12;26515:19;;26174:366;;;:::o;26546:419::-;26712:4;26750:2;26739:9;26735:18;26727:26;;26799:9;26793:4;26789:20;26785:1;26774:9;26770:17;26763:47;26827:131;26953:4;26827:131;:::i;:::-;26819:139;;26546:419;;;:::o;26971:225::-;27111:34;27107:1;27099:6;27095:14;27088:58;27180:8;27175:2;27167:6;27163:15;27156:33;26971:225;:::o;27202:366::-;27344:3;27365:67;27429:2;27424:3;27365:67;:::i;:::-;27358:74;;27441:93;27530:3;27441:93;:::i;:::-;27559:2;27554:3;27550:12;27543:19;;27202:366;;;:::o;27574:419::-;27740:4;27778:2;27767:9;27763:18;27755:26;;27827:9;27821:4;27817:20;27813:1;27802:9;27798:17;27791:47;27855:131;27981:4;27855:131;:::i;:::-;27847:139;;27574:419;;;:::o;27999:182::-;28139:34;28135:1;28127:6;28123:14;28116:58;27999:182;:::o;28187:366::-;28329:3;28350:67;28414:2;28409:3;28350:67;:::i;:::-;28343:74;;28426:93;28515:3;28426:93;:::i;:::-;28544:2;28539:3;28535:12;28528:19;;28187:366;;;:::o;28559:419::-;28725:4;28763:2;28752:9;28748:18;28740:26;;28812:9;28806:4;28802:20;28798:1;28787:9;28783:17;28776:47;28840:131;28966:4;28840:131;:::i;:::-;28832:139;;28559:419;;;:::o;28984:181::-;29124:33;29120:1;29112:6;29108:14;29101:57;28984:181;:::o;29171:366::-;29313:3;29334:67;29398:2;29393:3;29334:67;:::i;:::-;29327:74;;29410:93;29499:3;29410:93;:::i;:::-;29528:2;29523:3;29519:12;29512:19;;29171:366;;;:::o;29543:419::-;29709:4;29747:2;29736:9;29732:18;29724:26;;29796:9;29790:4;29786:20;29782:1;29771:9;29767:17;29760:47;29824:131;29950:4;29824:131;:::i;:::-;29816:139;;29543:419;;;:::o;29968:220::-;30108:34;30104:1;30096:6;30092:14;30085:58;30177:3;30172:2;30164:6;30160:15;30153:28;29968:220;:::o;30194:366::-;30336:3;30357:67;30421:2;30416:3;30357:67;:::i;:::-;30350:74;;30433:93;30522:3;30433:93;:::i;:::-;30551:2;30546:3;30542:12;30535:19;;30194:366;;;:::o;30566:419::-;30732:4;30770:2;30759:9;30755:18;30747:26;;30819:9;30813:4;30809:20;30805:1;30794:9;30790:17;30783:47;30847:131;30973:4;30847:131;:::i;:::-;30839:139;;30566:419;;;:::o;30991:221::-;31131:34;31127:1;31119:6;31115:14;31108:58;31200:4;31195:2;31187:6;31183:15;31176:29;30991:221;:::o;31218:366::-;31360:3;31381:67;31445:2;31440:3;31381:67;:::i;:::-;31374:74;;31457:93;31546:3;31457:93;:::i;:::-;31575:2;31570:3;31566:12;31559:19;;31218:366;;;:::o;31590:419::-;31756:4;31794:2;31783:9;31779:18;31771:26;;31843:9;31837:4;31833:20;31829:1;31818:9;31814:17;31807:47;31871:131;31997:4;31871:131;:::i;:::-;31863:139;;31590:419;;;:::o;32015:172::-;32155:24;32151:1;32143:6;32139:14;32132:48;32015:172;:::o;32193:366::-;32335:3;32356:67;32420:2;32415:3;32356:67;:::i;:::-;32349:74;;32432:93;32521:3;32432:93;:::i;:::-;32550:2;32545:3;32541:12;32534:19;;32193:366;;;:::o;32565:419::-;32731:4;32769:2;32758:9;32754:18;32746:26;;32818:9;32812:4;32808:20;32804:1;32793:9;32789:17;32782:47;32846:131;32972:4;32846:131;:::i;:::-;32838:139;;32565:419;;;:::o;32990:179::-;33130:31;33126:1;33118:6;33114:14;33107:55;32990:179;:::o;33175:366::-;33317:3;33338:67;33402:2;33397:3;33338:67;:::i;:::-;33331:74;;33414:93;33503:3;33414:93;:::i;:::-;33532:2;33527:3;33523:12;33516:19;;33175:366;;;:::o;33547:419::-;33713:4;33751:2;33740:9;33736:18;33728:26;;33800:9;33794:4;33790:20;33786:1;33775:9;33771:17;33764:47;33828:131;33954:4;33828:131;:::i;:::-;33820:139;;33547:419;;;:::o;33972:180::-;34020:77;34017:1;34010:88;34117:4;34114:1;34107:15;34141:4;34138:1;34131:15;34158:98;34209:6;34243:5;34237:12;34227:22;;34158:98;;;:::o;34262:116::-;34313:4;34336:3;34328:11;;34366:4;34361:3;34357:14;34349:22;;34262:116;;;:::o;34384:154::-;34427:11;34463:29;34487:3;34481:10;34463:29;:::i;:::-;34526:5;34502:29;;34439:99;34384:154;;;:::o;34544:594::-;34628:5;34659:38;34691:5;34659:38;:::i;:::-;34722:5;34749:40;34783:5;34749:40;:::i;:::-;34737:52;;34808:35;34834:8;34808:35;:::i;:::-;34799:44;;34867:2;34859:6;34856:14;34853:278;;;34938:169;35023:66;34993:6;34989:2;34985:15;34982:1;34978:23;34938:169;:::i;:::-;34915:5;34894:227;34885:236;;34853:278;34634:504;;34544:594;;;:::o;35144:664::-;35349:4;35387:3;35376:9;35372:19;35364:27;;35401:71;35469:1;35458:9;35454:17;35445:6;35401:71;:::i;:::-;35482:72;35550:2;35539:9;35535:18;35526:6;35482:72;:::i;:::-;35564;35632:2;35621:9;35617:18;35608:6;35564:72;:::i;:::-;35646;35714:2;35703:9;35699:18;35690:6;35646:72;:::i;:::-;35728:73;35796:3;35785:9;35781:19;35772:6;35728:73;:::i;:::-;35144:664;;;;;;;;:::o;35814:170::-;35954:22;35950:1;35942:6;35938:14;35931:46;35814:170;:::o;35990:366::-;36132:3;36153:67;36217:2;36212:3;36153:67;:::i;:::-;36146:74;;36229:93;36318:3;36229:93;:::i;:::-;36347:2;36342:3;36338:12;36331:19;;35990:366;;;:::o;36362:419::-;36528:4;36566:2;36555:9;36551:18;36543:26;;36615:9;36609:4;36605:20;36601:1;36590:9;36586:17;36579:47;36643:131;36769:4;36643:131;:::i;:::-;36635:139;;36362:419;;;:::o;36787:194::-;36827:4;36847:20;36865:1;36847:20;:::i;:::-;36842:25;;36881:20;36899:1;36881:20;:::i;:::-;36876:25;;36925:1;36922;36918:9;36910:17;;36949:1;36943:4;36940:11;36937:37;;;36954:18;;:::i;:::-;36937:37;36787:194;;;;:::o;36987:166::-;37127:18;37123:1;37115:6;37111:14;37104:42;36987:166;:::o;37159:366::-;37301:3;37322:67;37386:2;37381:3;37322:67;:::i;:::-;37315:74;;37398:93;37487:3;37398:93;:::i;:::-;37516:2;37511:3;37507:12;37500:19;;37159:366;;;:::o;37531:419::-;37697:4;37735:2;37724:9;37720:18;37712:26;;37784:9;37778:4;37774:20;37770:1;37759:9;37755:17;37748:47;37812:131;37938:4;37812:131;:::i;:::-;37804:139;;37531:419;;;:::o;37956:545::-;38129:4;38167:3;38156:9;38152:19;38144:27;;38181:71;38249:1;38238:9;38234:17;38225:6;38181:71;:::i;:::-;38262:68;38326:2;38315:9;38311:18;38302:6;38262:68;:::i;:::-;38340:72;38408:2;38397:9;38393:18;38384:6;38340:72;:::i;:::-;38422;38490:2;38479:9;38475:18;38466:6;38422:72;:::i;:::-;37956:545;;;;;;;:::o;38507:180::-;38555:77;38552:1;38545:88;38652:4;38649:1;38642:15;38676:4;38673:1;38666:15;38693:174;38833:26;38829:1;38821:6;38817:14;38810:50;38693:174;:::o;38873:366::-;39015:3;39036:67;39100:2;39095:3;39036:67;:::i;:::-;39029:74;;39112:93;39201:3;39112:93;:::i;:::-;39230:2;39225:3;39221:12;39214:19;;38873:366;;;:::o;39245:419::-;39411:4;39449:2;39438:9;39434:18;39426:26;;39498:9;39492:4;39488:20;39484:1;39473:9;39469:17;39462:47;39526:131;39652:4;39526:131;:::i;:::-;39518:139;;39245:419;;;:::o;39670:181::-;39810:33;39806:1;39798:6;39794:14;39787:57;39670:181;:::o;39857:366::-;39999:3;40020:67;40084:2;40079:3;40020:67;:::i;:::-;40013:74;;40096:93;40185:3;40096:93;:::i;:::-;40214:2;40209:3;40205:12;40198:19;;39857:366;;;:::o;40229:419::-;40395:4;40433:2;40422:9;40418:18;40410:26;;40482:9;40476:4;40472:20;40468:1;40457:9;40453:17;40446:47;40510:131;40636:4;40510:131;:::i;:::-;40502:139;;40229:419;;;:::o;40654:221::-;40794:34;40790:1;40782:6;40778:14;40771:58;40863:4;40858:2;40850:6;40846:15;40839:29;40654:221;:::o;40881:366::-;41023:3;41044:67;41108:2;41103:3;41044:67;:::i;:::-;41037:74;;41120:93;41209:3;41120:93;:::i;:::-;41238:2;41233:3;41229:12;41222:19;;40881:366;;;:::o;41253:419::-;41419:4;41457:2;41446:9;41442:18;41434:26;;41506:9;41500:4;41496:20;41492:1;41481:9;41477:17;41470:47;41534:131;41660:4;41534:131;:::i;:::-;41526:139;;41253:419;;;:::o;41678:180::-;41726:77;41723:1;41716:88;41823:4;41820:1;41813:15;41847:4;41844:1;41837:15;41864:185;41904:1;41921:20;41939:1;41921:20;:::i;:::-;41916:25;;41955:20;41973:1;41955:20;:::i;:::-;41950:25;;41994:1;41984:35;;41999:18;;:::i;:::-;41984:35;42041:1;42038;42034:9;42029:14;;41864:185;;;;:::o

ipfs://ec2d38ab11b81f298bee2296502a12842026f78687172098e1b3632892a8361b