Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library AddressUpgradeable
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(
•    - function _revert(bytes memory returnd ...
•    - function _disableInitializers()
•    - function _getInitializedVersion()
•    - function _isInitializing()
•    - function __Context_init()
•    - function __Context_init_unchained()
•    - function _msgSender()
•    - function _msgData()
•    - function __Ownable_init()
•    - function __Ownable_init_unchained()
•    - 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(
• library EnumerableSet
•    - function _add(Set storage set, bytes3 ...
•    - function _remove(Set storage set, byt ...
•    - function _contains(Set storage set, b ...
•    - function _length(Set storage set)
•    - function _at(Set storage set, uint256 ...
•    - function _values(Set storage set)
•    - function add(Bytes32Set storage set, ...
•    - function remove(Bytes32Set storage se ...
•    - function contains(Bytes32Set storage ...
•    - function length(Bytes32Set storage se ...
•    - function at(Bytes32Set storage set, u ...
•    - function values(Bytes32Set storage se ...
•    - function add(AddressSet storage set, ...
•    - function remove(AddressSet storage se ...
•    - function contains(AddressSet storage ...
•    - function length(AddressSet storage se ...
•    - function at(AddressSet storage set, u ...
•    - function values(AddressSet storage se ...
•    - function add(UintSet storage set, uin ...
•    - function remove(UintSet storage set, ...
•    - function contains(UintSet storage set ...
•    - function length(UintSet storage set)
•    - function at(UintSet storage set, uint ...
•    - function values(UintSet storage set)
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(
•    - function mulDiv(
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•    - function log2(uint256 value)
•    - function log2(uint256 value, Rounding ...
•    - function log10(uint256 value)
•    - function log10(uint256 value, Roundin ...
•    - function log256(uint256 value)
•    - function log256(uint256 value, Roundi ...
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
• library ECDSA
•    - function _throwError(RecoverError err ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes ...
•    - function tryRecover(
•    - function recover(
•    - function tryRecover(
•    - function recover(
•    - function toEthSignedMessageHash(bytes ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toTypedDataHash(bytes32 doma ...
• library SignatureChecker
•    - function validSignature(
•    - function requireValidSignature(
•  contract TokenDistributor is Ownab ... *
•    - function initialize( address token_)
•    - function canClaimAmount()
•    - function claim(uint128 nonce, bytes c ...
•    - function getInfoView(address user)
•    - function burn()
•    - function addSigner(address val)
•    - function delSigner(address signer)
•    - function getSigners()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

// File: @openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

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

// File: @openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol

// OpenZeppelin Contracts (last updated v4.8.1) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.2;

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    uint8 private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint8 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
     * constructor.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        bool isTopLevelCall = !_initializing;
        require(
            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
            "Initializable: contract is already initialized"
        );
        _initialized = 1;
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: setting the version to 255 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint8 version) {
        require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
        _initialized = version;
        _initializing = true;
        _;
        _initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        require(!_initializing, "Initializable: contract is initializing");
        if (_initialized < type(uint8).max) {
            _initialized = type(uint8).max;
            emit Initialized(type(uint8).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint8) {
        return _initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _initializing;
    }
}

// File: @openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.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 ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
    }

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// File: @openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol

// OpenZeppelin Contracts (last updated v4.7.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 OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal onlyInitializing {
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal onlyInitializing {
        _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 anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing 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);
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

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

// OpenZeppelin Contracts (last updated v4.6.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/contracts/utils/structs/EnumerableSet.sol

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

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

// OpenZeppelin Contracts (last updated v4.8.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) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @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) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

// File: contracts/libs/SignatureChecker.sol

// Copyright (c) 2021 the ethier authors (github.com/divergencetech/ethier)
pragma solidity >=0.6.12;


library SignatureChecker {
    using EnumerableSet for EnumerableSet.AddressSet;

    /**
    @notice Common validator logic, checking if the recovered signer is
    contained in the signers AddressSet.
    */
    function validSignature(
        EnumerableSet.AddressSet storage signers,
        bytes32 message,
        bytes calldata signature
    ) internal view returns (bool) {
        return signers.contains(ECDSA.recover(message, signature));
    }

    /**
    @notice Requires that the recovered signer is contained in the signers
    AddressSet.
    @dev Convenience wrapper that reverts if the signature validation fails.
    */
    function requireValidSignature(
        EnumerableSet.AddressSet storage signers,
        bytes32 message,
        bytes calldata signature
    ) internal view {
        require(
            validSignature(signers, message, signature),
            "SignatureChecker: Invalid signature"
        );
    }

    
}

// File: contracts/pool/TokenDistributor.sol


pragma solidity =0.8.19;




contract TokenDistributor is OwnableUpgradeable {
    using EnumerableSet for EnumerableSet.AddressSet;
    using SignatureChecker for EnumerableSet.AddressSet;

    uint256 public constant MAX_ADDRESSES = 150000;
    uint256 public constant MAX_TOKEN = 420_000_000_000_000 * 1e18;
    uint256 public constant INIT_CLAIM = 131_250_000_000* 1e18; 

    struct InfoView {
        uint256 maxToken;
        uint256 initClaim;
        uint256 currentClaim;
        bool claimed;
        uint256 claimedSupply;
        uint256 claimedCount;
    }

    event Claim(address indexed user, uint128 nonce, uint256 amount, uint timestamp);

    IERC20 public token;

    EnumerableSet.AddressSet private _signers;
    mapping(uint256 => bool) public _usedNonce;
    mapping(address => bool) public _claimedUser;

    uint256 public claimedSupply = 0;
    uint256 public claimedCount = 0;
    uint256 public claimedPercentage = 0;
    address public burnAddress = 0x000000000000000000000000000000000000dEaD;
    


    function initialize( address token_) external initializer {
        __Ownable_init();
        token = IERC20(token_);
    }

    function canClaimAmount() public view returns(uint256) {
        
        if (claimedCount >= MAX_ADDRESSES) {
            return 0;
        }

        uint256 supplyPerAddress = INIT_CLAIM;
        // uint256 curClaimedCount = claimedCount + 1;
        uint256 claimedPercent = claimedSupply*1000/MAX_TOKEN;
        uint256 curPercent = 125;

        while (curPercent <= claimedPercent) {
            supplyPerAddress = (supplyPerAddress * 50) / 100;
            curPercent += 125;
        }

        return supplyPerAddress;
    }

    function claim(uint128 nonce, bytes calldata signature) public {
        require(_usedNonce[nonce] == false, "nonce already used");
        require(_claimedUser[_msgSender()] == false, "already claimed");
        // require(msg.sender.balance >= MIN_BALANCE, "Insufficient balance which less than 0.2e");

        _claimedUser[_msgSender()] = true;
        bytes32 message = keccak256(abi.encode(address(this), _msgSender(), nonce));

        _signers.requireValidSignature(message, signature);
        _usedNonce[nonce] = true;

        uint256 supplyPerAddress = canClaimAmount();
        require(supplyPerAddress >= 1e6, "Airdrop has ended");

        uint256 amount = canClaimAmount();
        token.transfer(_msgSender(), amount);

        claimedCount++;
        claimedSupply += supplyPerAddress;

        if (claimedCount > 0) {
            claimedPercentage = (claimedCount * 100) / MAX_ADDRESSES;
        }

        emit Claim(_msgSender(), nonce, amount, block.timestamp);
    }

    function getInfoView(address user) public view returns(InfoView memory) {
        return InfoView({
            maxToken: MAX_TOKEN,
            initClaim: INIT_CLAIM,
            currentClaim: canClaimAmount(),
            claimed: _claimedUser[user],
            claimedSupply: claimedSupply,
            claimedCount: claimedCount
        });
    }

    function burn() public onlyOwner(){
        token.transfer(burnAddress, token.balanceOf(address(this)));
    }

    function addSigner(address val) public onlyOwner() {
        require(val != address(0), "Giggity: val is the zero address");
        _signers.add(val);
    }

    function delSigner(address signer) public onlyOwner returns (bool) {
        require(signer != address(0), "Giggity: signer is the zero address");
        return _signers.remove(signer);
    }

    function getSigners() public view returns (address[] memory ret) {
        return _signers.values();
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint128","name":"nonce","type":"uint128"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","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"},{"inputs":[],"name":"INIT_CLAIM","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_ADDRESSES","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_TOKEN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_claimedUser","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"_usedNonce","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"val","type":"address"}],"name":"addSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"burnAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"canClaimAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint128","name":"nonce","type":"uint128"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimedCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimedPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimedSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"signer","type":"address"}],"name":"delSigner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getInfoView","outputs":[{"components":[{"internalType":"uint256","name":"maxToken","type":"uint256"},{"internalType":"uint256","name":"initClaim","type":"uint256"},{"internalType":"uint256","name":"currentClaim","type":"uint256"},{"internalType":"bool","name":"claimed","type":"bool"},{"internalType":"uint256","name":"claimedSupply","type":"uint256"},{"internalType":"uint256","name":"claimedCount","type":"uint256"}],"internalType":"struct TokenDistributor.InfoView","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSigners","outputs":[{"internalType":"address[]","name":"ret","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

61392:3723:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63123:1014;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62121:42;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64513:112;;;:::i;:::-;;61562:46;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61615:62;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62343:71;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;18851:103;;;:::i;:::-;;62565:550;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64801:195;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;18203:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65004:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62170:44;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62223:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62262:31;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62431:126;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;61684:58;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64633:160;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62300:36;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19109:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62045:19;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64145:360;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63123:1014;63226:5;63205:26;;:10;:17;63216:5;63205:17;;;;;;;;;;;;;;;;;;;;;;;:26;;;63197:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;63303:5;63273:35;;:12;:26;63286:12;:10;:12::i;:::-;63273:26;;;;;;;;;;;;;;;;;;;;;;;;;:35;;;63265:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;63471:4;63442:12;:26;63455:12;:10;:12::i;:::-;63442:26;;;;;;;;;;;;;;;;:33;;;;;;;;;;;;;;;;;;63486:15;63533:4;63540:12;:10;:12::i;:::-;63554:5;63514:46;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;63504:57;;;;;;63486:75;;63574:50;63605:7;63614:9;;63574:8;:30;;:50;;;;;;:::i;:::-;63655:4;63635:10;:17;63646:5;63635:17;;;;;;;;;;;;;;:24;;;;;;;;;;;;;;;;;;63672;63699:16;:14;:16::i;:::-;63672:43;;63754:3;63734:16;:23;;63726:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;63792:14;63809:16;:14;:16::i;:::-;63792:33;;63836:5;;;;;;;;;;;:14;;;63851:12;:10;:12::i;:::-;63865:6;63836:36;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;63885:12;;:14;;;;;;;;;:::i;:::-;;;;;;63927:16;63910:13;;:33;;;;;;;:::i;:::-;;;;;;;;63975:1;63960:12;;:16;63956:105;;;61602:6;64029:3;64014:12;;:18;;;;:::i;:::-;64013:36;;;;:::i;:::-;63993:17;:56;;;;63956:105;64084:12;:10;:12::i;:::-;64078:51;;;64098:5;64105:6;64113:15;64078:51;;;;;;;;:::i;:::-;;;;;;;;63186:951;;;63123:1014;;;:::o;62121:42::-;;;;;;;;;;;;;;;;;;;;;;:::o;64513:112::-;18089:13;:11;:13::i;:::-;64558:5:::1;;;;;;;;;;;:14;;;64573:11;;;;;;;;;;;64586:5;;;;;;;;;;;:15;;;64610:4;64586:30;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64558:59;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;64513:112::o:0;61562:46::-;61602:6;61562:46;:::o;61615:62::-;61651:26;61615:62;:::o;62343:71::-;;;;;;;;;;;;;:::o;18851:103::-;18089:13;:11;:13::i;:::-;18916:30:::1;18943:1;18916:18;:30::i;:::-;18851:103::o:0;62565:550::-;62611:7;61602:6;62645:12;;:29;62641:70;;62698:1;62691:8;;;;62641:70;62723:24;61721:21;62723:37;;62827:22;61651:26;62866:4;62852:13;;:18;;;;:::i;:::-;:28;;;;:::i;:::-;62827:53;;62891:18;62912:3;62891:24;;62928:144;62949:14;62935:10;:28;62928:144;;63025:3;63019:2;63000:16;:21;;;;:::i;:::-;62999:29;;;;:::i;:::-;62980:48;;63057:3;63043:17;;;;;:::i;:::-;;;62928:144;;;63091:16;63084:23;;;;;62565:550;;:::o;64801:195::-;64862:4;18089:13;:11;:13::i;:::-;64905:1:::1;64887:20;;:6;:20;;::::0;64879:68:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;64965:23;64981:6;64965:8;:15;;:23;;;;:::i;:::-;64958:30;;64801:195:::0;;;:::o;18203:87::-;18249:7;18276:6;;;;;;;;;;;18269:13;;18203:87;:::o;65004:108::-;65047:20;65087:17;:8;:15;:17::i;:::-;65080:24;;65004:108;:::o;62170:44::-;;;;;;;;;;;;;;;;;;;;;;:::o;62223:32::-;;;;:::o;62262:31::-;;;;:::o;62431:126::-;11928:19;11951:13;;;;;;;;;;;11950:14;11928:36;;11998:14;:34;;;;;12031:1;12016:12;;;;;;;;;;:16;;;11998:34;11997:108;;;;12039:44;12077:4;12039:29;:44::i;:::-;12038:45;:66;;;;;12103:1;12087:12;;;;;;;;;;:17;;;12038:66;11997:108;11975:204;;;;;;;;;;;;:::i;:::-;;;;;;;;;12205:1;12190:12;;:16;;;;;;;;;;;;;;;;;;12221:14;12217:67;;;12268:4;12252:13;;:20;;;;;;;;;;;;;;;;;;12217:67;62500:16:::1;:14;:16::i;:::-;62542:6;62527:5;;:22;;;;;;;;;;;;;;;;;;12310:14:::0;12306:102;;;12357:5;12341:13;;:21;;;;;;;;;;;;;;;;;;12382:14;12394:1;12382:14;;;;;;:::i;:::-;;;;;;;;12306:102;11917:498;62431:126;:::o;61684:58::-;61721:21;61684:58;:::o;64633:160::-;18089:13;:11;:13::i;:::-;64718:1:::1;64703:17;;:3;:17;;::::0;64695:62:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;64768:17;64781:3;64768:8;:12;;:17;;;;:::i;:::-;;64633:160:::0;:::o;62300:36::-;;;;:::o;19109:201::-;18089:13;:11;:13::i;:::-;19218:1:::1;19198:22;;:8;:22;;::::0;19190:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;19274:28;19293:8;19274:18;:28::i;:::-;19109:201:::0;:::o;62045:19::-;;;;;;;;;;;;;:::o;64145:360::-;64200:15;;:::i;:::-;64235:262;;;;;;;;61651:26;64235:262;;;;61721:21;64235:262;;;;64343:16;:14;:16::i;:::-;64235:262;;;;64383:12;:18;64396:4;64383:18;;;;;;;;;;;;;;;;;;;;;;;;;64235:262;;;;;;64431:13;;64235:262;;;;64473:12;;64235:262;;;64228:269;;64145:360;;;:::o;16245:98::-;16298:7;16325:10;16318:17;;16245:98;:::o;60982:311::-;61179:43;61194:7;61203;61212:9;;61179:14;:43::i;:::-;61157:128;;;;;;;;;;;;:::i;:::-;;;;;;;;;60982:311;;;;:::o;18368:132::-;18443:12;:10;:12::i;:::-;18432:23;;:7;:5;:7::i;:::-;:23;;;18424:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;18368:132::o;19470:191::-;19544:16;19563:6;;;;;;;;;;;19544:25;;19589:8;19580:6;;:17;;;;;;;;;;;;;;;;;;19644:8;19613:40;;19634:8;19613:40;;;;;;;;;;;;19533:128;19470:191;:::o;31745:158::-;31818:4;31842:53;31850:3;:10;;31886:5;31870:23;;31862:32;;31842:7;:53::i;:::-;31835:60;;31745:158;;;;:::o;33421:310::-;33484:16;33513:22;33538:19;33546:3;:10;;33538:7;:19::i;:::-;33513:44;;33568:23;33682:5;33672:15;;33717:6;33710:13;;;;33421:310;;;:::o;1298:326::-;1358:4;1615:1;1593:7;:19;;;:23;1586:30;;1298:326;;;:::o;17746:97::-;14071:13;;;;;;;;;;;14063:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;17809:26:::1;:24;:26::i;:::-;17746:97::o:0;31417:152::-;31487:4;31511:50;31516:3;:10;;31552:5;31536:23;;31528:32;;31511:4;:50::i;:::-;31504:57;;31417:152;;;;:::o;60537:249::-;60703:4;60727:51;60744:33;60758:7;60767:9;;60744:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:13;:33::i;:::-;60727:7;:16;;:51;;;;:::i;:::-;60720:58;;60537:249;;;;;;:::o;25738:1420::-;25804:4;25922:18;25943:3;:12;;:19;25956:5;25943:19;;;;;;;;;;;;25922:40;;25993:1;25979:10;:15;25975:1176;;26354:21;26391:1;26378:10;:14;;;;:::i;:::-;26354:38;;26407:17;26448:1;26427:3;:11;;:18;;;;:22;;;;:::i;:::-;26407:42;;26483:13;26470:9;:26;26466:405;;26517:17;26537:3;:11;;26549:9;26537:22;;;;;;;;:::i;:::-;;;;;;;;;;26517:42;;26691:9;26662:3;:11;;26674:13;26662:26;;;;;;;;:::i;:::-;;;;;;;;;:38;;;;26802:10;26776:3;:12;;:23;26789:9;26776:23;;;;;;;;;;;:36;;;;26498:373;26466:405;26952:3;:11;;:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;27047:3;:12;;:19;27060:5;27047:19;;;;;;;;;;;27040:26;;;27090:4;27083:11;;;;;;;25975:1176;27134:5;27127:12;;;25738:1420;;;;;:::o;28592:111::-;28648:16;28684:3;:11;;28677:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28592:111;;;:::o;17851:113::-;14071:13;;;;;;;;;;;14063:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;17924:32:::1;17943:12;:10;:12::i;:::-;17924:18;:32::i;:::-;17851:113::o:0;25148:414::-;25211:4;25233:21;25243:3;25248:5;25233:9;:21::i;:::-;25228:327;;25271:3;:11;;25288:5;25271:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25454:3;:11;;:18;;;;25432:3;:12;;:19;25445:5;25432:19;;;;;;;;;;;:40;;;;25494:4;25487:11;;;;25228:327;25538:5;25531:12;;25148:414;;;;;:::o;55155:231::-;55233:7;55254:17;55273:18;55295:27;55306:4;55312:9;55295:10;:27::i;:::-;55253:69;;;;55333:18;55345:5;55333:11;:18::i;:::-;55369:9;55362:16;;;;55155:231;;;;:::o;31989:167::-;32069:4;32093:55;32103:3;:10;;32139:5;32123:23;;32115:32;;32093:9;:55::i;:::-;32086:62;;31989:167;;;;:::o;27244:129::-;27317:4;27364:1;27341:3;:12;;:19;27354:5;27341:19;;;;;;;;;;;;:24;;27334:31;;27244:129;;;;:::o;53606:747::-;53687:7;53696:12;53745:2;53725:9;:16;:22;53721:625;;53764:9;53788;53812:7;54069:4;54058:9;54054:20;54048:27;54043:32;;54119:4;54108:9;54104:20;54098:27;54093:32;;54177:4;54166:9;54162:20;54156:27;54153:1;54148:36;54143:41;;54220:25;54231:4;54237:1;54240;54243;54220:10;:25::i;:::-;54213:32;;;;;;;;;53721:625;54294:1;54298:35;54278:56;;;;53606:747;;;;;;:::o;51999:521::-;52077:20;52068:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;52064:449;52114:7;52064:449;52175:29;52166:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;52162:351;;52221:34;;;;;;;;;;:::i;:::-;;;;;;;;52162:351;52286:35;52277:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;52273:240;;52338:41;;;;;;;;;;:::i;:::-;;;;;;;;52273:240;52410:30;52401:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;52397:116;;52457:44;;;;;;;;;;:::i;:::-;;;;;;;;52397:116;51999:521;;:::o;56607:1520::-;56738:7;56747:12;57672:66;57667:1;57659:10;;:79;57655:163;;;57771:1;57775:30;57755:51;;;;;;57655:163;57915:14;57932:24;57942:4;57948:1;57951;57954;57932:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57915:41;;57989:1;57971:20;;:6;:20;;;57967:103;;58024:1;58028:29;58008:50;;;;;;;57967:103;58090:6;58098:20;58082:37;;;;;56607:1520;;;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;88:117:1:-;197:1;194;187:12;211:117;320:1;317;310:12;334:118;371:7;411:34;404:5;400:46;389:57;;334:118;;;:::o;458:122::-;531:24;549:5;531:24;:::i;:::-;524:5;521:35;511:63;;570:1;567;560:12;511:63;458:122;:::o;586:139::-;632:5;670:6;657:20;648:29;;686:33;713:5;686:33;:::i;:::-;586:139;;;;:::o;731:117::-;840:1;837;830:12;854:117;963:1;960;953:12;977:117;1086:1;1083;1076:12;1113:552;1170:8;1180:6;1230:3;1223:4;1215:6;1211:17;1207:27;1197:122;;1238:79;;:::i;:::-;1197:122;1351:6;1338:20;1328:30;;1381:18;1373:6;1370:30;1367:117;;;1403:79;;:::i;:::-;1367:117;1517:4;1509:6;1505:17;1493:29;;1571:3;1563:4;1555:6;1551:17;1541:8;1537:32;1534:41;1531:128;;;1578:79;;:::i;:::-;1531:128;1113:552;;;;;:::o;1671:672::-;1750:6;1758;1766;1815:2;1803:9;1794:7;1790:23;1786:32;1783:119;;;1821:79;;:::i;:::-;1783:119;1941:1;1966:53;2011:7;2002:6;1991:9;1987:22;1966:53;:::i;:::-;1956:63;;1912:117;2096:2;2085:9;2081:18;2068:32;2127:18;2119:6;2116:30;2113:117;;;2149:79;;:::i;:::-;2113:117;2262:64;2318:7;2309:6;2298:9;2294:22;2262:64;:::i;:::-;2244:82;;;;2039:297;1671:672;;;;;:::o;2349:77::-;2386:7;2415:5;2404:16;;2349:77;;;:::o;2432:122::-;2505:24;2523:5;2505:24;:::i;:::-;2498:5;2495:35;2485:63;;2544:1;2541;2534:12;2485:63;2432:122;:::o;2560:139::-;2606:5;2644:6;2631:20;2622:29;;2660:33;2687:5;2660:33;:::i;:::-;2560:139;;;;:::o;2705:329::-;2764:6;2813:2;2801:9;2792:7;2788:23;2784:32;2781:119;;;2819:79;;:::i;:::-;2781:119;2939:1;2964:53;3009:7;3000:6;2989:9;2985:22;2964:53;:::i;:::-;2954:63;;2910:117;2705:329;;;;:::o;3040:90::-;3074:7;3117:5;3110:13;3103:21;3092:32;;3040:90;;;:::o;3136:109::-;3217:21;3232:5;3217:21;:::i;:::-;3212:3;3205:34;3136:109;;:::o;3251:210::-;3338:4;3376:2;3365:9;3361:18;3353:26;;3389:65;3451:1;3440:9;3436:17;3427:6;3389:65;:::i;:::-;3251:210;;;;:::o;3467:118::-;3554:24;3572:5;3554:24;:::i;:::-;3549:3;3542:37;3467:118;;:::o;3591:222::-;3684:4;3722:2;3711:9;3707:18;3699:26;;3735:71;3803:1;3792:9;3788:17;3779:6;3735:71;:::i;:::-;3591:222;;;;:::o;3819:126::-;3856:7;3896:42;3889:5;3885:54;3874:65;;3819:126;;;:::o;3951:96::-;3988:7;4017:24;4035:5;4017:24;:::i;:::-;4006:35;;3951:96;;;:::o;4053:118::-;4140:24;4158:5;4140:24;:::i;:::-;4135:3;4128:37;4053:118;;:::o;4177:222::-;4270:4;4308:2;4297:9;4293:18;4285:26;;4321:71;4389:1;4378:9;4374:17;4365:6;4321:71;:::i;:::-;4177:222;;;;:::o;4405:122::-;4478:24;4496:5;4478:24;:::i;:::-;4471:5;4468:35;4458:63;;4517:1;4514;4507:12;4458:63;4405:122;:::o;4533:139::-;4579:5;4617:6;4604:20;4595:29;;4633:33;4660:5;4633:33;:::i;:::-;4533:139;;;;:::o;4678:329::-;4737:6;4786:2;4774:9;4765:7;4761:23;4757:32;4754:119;;;4792:79;;:::i;:::-;4754:119;4912:1;4937:53;4982:7;4973:6;4962:9;4958:22;4937:53;:::i;:::-;4927:63;;4883:117;4678:329;;;;:::o;5013:114::-;5080:6;5114:5;5108:12;5098:22;;5013:114;;;:::o;5133:184::-;5232:11;5266:6;5261:3;5254:19;5306:4;5301:3;5297:14;5282:29;;5133:184;;;;:::o;5323:132::-;5390:4;5413:3;5405:11;;5443:4;5438:3;5434:14;5426:22;;5323:132;;;:::o;5461:108::-;5538:24;5556:5;5538:24;:::i;:::-;5533:3;5526:37;5461:108;;:::o;5575:179::-;5644:10;5665:46;5707:3;5699:6;5665:46;:::i;:::-;5743:4;5738:3;5734:14;5720:28;;5575:179;;;;:::o;5760:113::-;5830:4;5862;5857:3;5853:14;5845:22;;5760:113;;;:::o;5909:732::-;6028:3;6057:54;6105:5;6057:54;:::i;:::-;6127:86;6206:6;6201:3;6127:86;:::i;:::-;6120:93;;6237:56;6287:5;6237:56;:::i;:::-;6316:7;6347:1;6332:284;6357:6;6354:1;6351:13;6332:284;;;6433:6;6427:13;6460:63;6519:3;6504:13;6460:63;:::i;:::-;6453:70;;6546:60;6599:6;6546:60;:::i;:::-;6536:70;;6392:224;6379:1;6376;6372:9;6367:14;;6332:284;;;6336:14;6632:3;6625:10;;6033:608;;;5909:732;;;;:::o;6647:373::-;6790:4;6828:2;6817:9;6813:18;6805:26;;6877:9;6871:4;6867:20;6863:1;6852:9;6848:17;6841:47;6905:108;7008:4;6999:6;6905:108;:::i;:::-;6897:116;;6647:373;;;;:::o;7026:60::-;7054:3;7075:5;7068:12;;7026:60;;;:::o;7092:142::-;7142:9;7175:53;7193:34;7202:24;7220:5;7202:24;:::i;:::-;7193:34;:::i;:::-;7175:53;:::i;:::-;7162:66;;7092:142;;;:::o;7240:126::-;7290:9;7323:37;7354:5;7323:37;:::i;:::-;7310:50;;7240:126;;;:::o;7372:140::-;7436:9;7469:37;7500:5;7469:37;:::i;:::-;7456:50;;7372:140;;;:::o;7518:159::-;7619:51;7664:5;7619:51;:::i;:::-;7614:3;7607:64;7518:159;;:::o;7683:250::-;7790:4;7828:2;7817:9;7813:18;7805:26;;7841:85;7923:1;7912:9;7908:17;7899:6;7841:85;:::i;:::-;7683:250;;;;:::o;7939:108::-;8016:24;8034:5;8016:24;:::i;:::-;8011:3;8004:37;7939:108;;:::o;8053:99::-;8124:21;8139:5;8124:21;:::i;:::-;8119:3;8112:34;8053:99;;:::o;8234:1236::-;8383:4;8378:3;8374:14;8474:4;8467:5;8463:16;8457:23;8493:63;8550:4;8545:3;8541:14;8527:12;8493:63;:::i;:::-;8398:168;8653:4;8646:5;8642:16;8636:23;8672:63;8729:4;8724:3;8720:14;8706:12;8672:63;:::i;:::-;8576:169;8835:4;8828:5;8824:16;8818:23;8854:63;8911:4;8906:3;8902:14;8888:12;8854:63;:::i;:::-;8755:172;9012:4;9005:5;9001:16;8995:23;9031:57;9082:4;9077:3;9073:14;9059:12;9031:57;:::i;:::-;8937:161;9189:4;9182:5;9178:16;9172:23;9208:63;9265:4;9260:3;9256:14;9242:12;9208:63;:::i;:::-;9108:173;9371:4;9364:5;9360:16;9354:23;9390:63;9447:4;9442:3;9438:14;9424:12;9390:63;:::i;:::-;9291:172;8352:1118;8234:1236;;:::o;9476:327::-;9621:4;9659:3;9648:9;9644:19;9636:27;;9673:123;9793:1;9782:9;9778:17;9769:6;9673:123;:::i;:::-;9476:327;;;;:::o;9809:169::-;9893:11;9927:6;9922:3;9915:19;9967:4;9962:3;9958:14;9943:29;;9809:169;;;;:::o;9984:168::-;10124:20;10120:1;10112:6;10108:14;10101:44;9984:168;:::o;10158:366::-;10300:3;10321:67;10385:2;10380:3;10321:67;:::i;:::-;10314:74;;10397:93;10486:3;10397:93;:::i;:::-;10515:2;10510:3;10506:12;10499:19;;10158:366;;;:::o;10530:419::-;10696:4;10734:2;10723:9;10719:18;10711:26;;10783:9;10777:4;10773:20;10769:1;10758:9;10754:17;10747:47;10811:131;10937:4;10811:131;:::i;:::-;10803:139;;10530:419;;;:::o;10955:165::-;11095:17;11091:1;11083:6;11079:14;11072:41;10955:165;:::o;11126:366::-;11268:3;11289:67;11353:2;11348:3;11289:67;:::i;:::-;11282:74;;11365:93;11454:3;11365:93;:::i;:::-;11483:2;11478:3;11474:12;11467:19;;11126:366;;;:::o;11498:419::-;11664:4;11702:2;11691:9;11687:18;11679:26;;11751:9;11745:4;11741:20;11737:1;11726:9;11722:17;11715:47;11779:131;11905:4;11779:131;:::i;:::-;11771:139;;11498:419;;;:::o;11923:118::-;12010:24;12028:5;12010:24;:::i;:::-;12005:3;11998:37;11923:118;;:::o;12047:442::-;12196:4;12234:2;12223:9;12219:18;12211:26;;12247:71;12315:1;12304:9;12300:17;12291:6;12247:71;:::i;:::-;12328:72;12396:2;12385:9;12381:18;12372:6;12328:72;:::i;:::-;12410;12478:2;12467:9;12463:18;12454:6;12410:72;:::i;:::-;12047:442;;;;;;:::o;12495:167::-;12635:19;12631:1;12623:6;12619:14;12612:43;12495:167;:::o;12668:366::-;12810:3;12831:67;12895:2;12890:3;12831:67;:::i;:::-;12824:74;;12907:93;12996:3;12907:93;:::i;:::-;13025:2;13020:3;13016:12;13009:19;;12668:366;;;:::o;13040:419::-;13206:4;13244:2;13233:9;13229:18;13221:26;;13293:9;13287:4;13283:20;13279:1;13268:9;13264:17;13257:47;13321:131;13447:4;13321:131;:::i;:::-;13313:139;;13040:419;;;:::o;13465:332::-;13586:4;13624:2;13613:9;13609:18;13601:26;;13637:71;13705:1;13694:9;13690:17;13681:6;13637:71;:::i;:::-;13718:72;13786:2;13775:9;13771:18;13762:6;13718:72;:::i;:::-;13465:332;;;;;:::o;13803:116::-;13873:21;13888:5;13873:21;:::i;:::-;13866:5;13863:32;13853:60;;13909:1;13906;13899:12;13853:60;13803:116;:::o;13925:137::-;13979:5;14010:6;14004:13;13995:22;;14026:30;14050:5;14026:30;:::i;:::-;13925:137;;;;:::o;14068:345::-;14135:6;14184:2;14172:9;14163:7;14159:23;14155:32;14152:119;;;14190:79;;:::i;:::-;14152:119;14310:1;14335:61;14388:7;14379:6;14368:9;14364:22;14335:61;:::i;:::-;14325:71;;14281:125;14068:345;;;;:::o;14419:180::-;14467:77;14464:1;14457:88;14564:4;14561:1;14554:15;14588:4;14585:1;14578:15;14605:233;14644:3;14667:24;14685:5;14667:24;:::i;:::-;14658:33;;14713:66;14706:5;14703:77;14700:103;;14783:18;;:::i;:::-;14700:103;14830:1;14823:5;14819:13;14812:20;;14605:233;;;:::o;14844:191::-;14884:3;14903:20;14921:1;14903:20;:::i;:::-;14898:25;;14937:20;14955:1;14937:20;:::i;:::-;14932:25;;14980:1;14977;14973:9;14966:16;;15001:3;14998:1;14995:10;14992:36;;;15008:18;;:::i;:::-;14992:36;14844:191;;;;:::o;15041:410::-;15081:7;15104:20;15122:1;15104:20;:::i;:::-;15099:25;;15138:20;15156:1;15138:20;:::i;:::-;15133:25;;15193:1;15190;15186:9;15215:30;15233:11;15215:30;:::i;:::-;15204:41;;15394:1;15385:7;15381:15;15378:1;15375:22;15355:1;15348:9;15328:83;15305:139;;15424:18;;:::i;:::-;15305:139;15089:362;15041:410;;;;:::o;15457:180::-;15505:77;15502:1;15495:88;15602:4;15599:1;15592:15;15626:4;15623:1;15616:15;15643:185;15683:1;15700:20;15718:1;15700:20;:::i;:::-;15695:25;;15734:20;15752:1;15734:20;:::i;:::-;15729:25;;15773:1;15763:35;;15778:18;;:::i;:::-;15763:35;15820:1;15817;15813:9;15808:14;;15643:185;;;;:::o;15834:442::-;15983:4;16021:2;16010:9;16006:18;15998:26;;16034:71;16102:1;16091:9;16087:17;16078:6;16034:71;:::i;:::-;16115:72;16183:2;16172:9;16168:18;16159:6;16115:72;:::i;:::-;16197;16265:2;16254:9;16250:18;16241:6;16197:72;:::i;:::-;15834:442;;;;;;:::o;16282:143::-;16339:5;16370:6;16364:13;16355:22;;16386:33;16413:5;16386:33;:::i;:::-;16282:143;;;;:::o;16431:351::-;16501:6;16550:2;16538:9;16529:7;16525:23;16521:32;16518:119;;;16556:79;;:::i;:::-;16518:119;16676:1;16701:64;16757:7;16748:6;16737:9;16733:22;16701:64;:::i;:::-;16691:74;;16647:128;16431:351;;;;:::o;16788:222::-;16928:34;16924:1;16916:6;16912:14;16905:58;16997:5;16992:2;16984:6;16980:15;16973:30;16788:222;:::o;17016:366::-;17158:3;17179:67;17243:2;17238:3;17179:67;:::i;:::-;17172:74;;17255:93;17344:3;17255:93;:::i;:::-;17373:2;17368:3;17364:12;17357:19;;17016:366;;;:::o;17388:419::-;17554:4;17592:2;17581:9;17577:18;17569:26;;17641:9;17635:4;17631:20;17627:1;17616:9;17612:17;17605:47;17669:131;17795:4;17669:131;:::i;:::-;17661:139;;17388:419;;;:::o;17813:233::-;17953:34;17949:1;17941:6;17937:14;17930:58;18022:16;18017:2;18009:6;18005:15;17998:41;17813:233;:::o;18052:366::-;18194:3;18215:67;18279:2;18274:3;18215:67;:::i;:::-;18208:74;;18291:93;18380:3;18291:93;:::i;:::-;18409:2;18404:3;18400:12;18393:19;;18052:366;;;:::o;18424:419::-;18590:4;18628:2;18617:9;18613:18;18605:26;;18677:9;18671:4;18667:20;18663:1;18652:9;18648:17;18641:47;18705:131;18831:4;18705:131;:::i;:::-;18697:139;;18424:419;;;:::o;18849:85::-;18894:7;18923:5;18912:16;;18849:85;;;:::o;18940:86::-;18975:7;19015:4;19008:5;19004:16;18993:27;;18940:86;;;:::o;19032:154::-;19088:9;19121:59;19137:42;19146:32;19172:5;19146:32;:::i;:::-;19137:42;:::i;:::-;19121:59;:::i;:::-;19108:72;;19032:154;;;:::o;19192:143::-;19285:43;19322:5;19285:43;:::i;:::-;19280:3;19273:56;19192:143;;:::o;19341:234::-;19440:4;19478:2;19467:9;19463:18;19455:26;;19491:77;19565:1;19554:9;19550:17;19541:6;19491:77;:::i;:::-;19341:234;;;;:::o;19581:182::-;19721:34;19717:1;19709:6;19705:14;19698:58;19581:182;:::o;19769:366::-;19911:3;19932:67;19996:2;19991:3;19932:67;:::i;:::-;19925:74;;20008:93;20097:3;20008:93;:::i;:::-;20126:2;20121:3;20117:12;20110:19;;19769:366;;;:::o;20141:419::-;20307:4;20345:2;20334:9;20330:18;20322:26;;20394:9;20388:4;20384:20;20380:1;20369:9;20365:17;20358:47;20422:131;20548:4;20422:131;:::i;:::-;20414:139;;20141:419;;;:::o;20566:225::-;20706:34;20702:1;20694:6;20690:14;20683:58;20775:8;20770:2;20762:6;20758:15;20751:33;20566:225;:::o;20797:366::-;20939:3;20960:67;21024:2;21019:3;20960:67;:::i;:::-;20953:74;;21036:93;21125:3;21036:93;:::i;:::-;21154:2;21149:3;21145:12;21138:19;;20797:366;;;:::o;21169:419::-;21335:4;21373:2;21362:9;21358:18;21350:26;;21422:9;21416:4;21412:20;21408:1;21397:9;21393:17;21386:47;21450:131;21576:4;21450:131;:::i;:::-;21442:139;;21169:419;;;:::o;21594:222::-;21734:34;21730:1;21722:6;21718:14;21711:58;21803:5;21798:2;21790:6;21786:15;21779:30;21594:222;:::o;21822:366::-;21964:3;21985:67;22049:2;22044:3;21985:67;:::i;:::-;21978:74;;22061:93;22150:3;22061:93;:::i;:::-;22179:2;22174:3;22170:12;22163:19;;21822:366;;;:::o;22194:419::-;22360:4;22398:2;22387:9;22383:18;22375:26;;22447:9;22441:4;22437:20;22433:1;22422:9;22418:17;22411:47;22475:131;22601:4;22475:131;:::i;:::-;22467:139;;22194:419;;;:::o;22619:182::-;22759:34;22755:1;22747:6;22743:14;22736:58;22619:182;:::o;22807:366::-;22949:3;22970:67;23034:2;23029:3;22970:67;:::i;:::-;22963:74;;23046:93;23135:3;23046:93;:::i;:::-;23164:2;23159:3;23155:12;23148:19;;22807:366;;;:::o;23179:419::-;23345:4;23383:2;23372:9;23368:18;23360:26;;23432:9;23426:4;23422:20;23418:1;23407:9;23403:17;23396:47;23460:131;23586:4;23460:131;:::i;:::-;23452:139;;23179:419;;;:::o;23604:230::-;23744:34;23740:1;23732:6;23728:14;23721:58;23813:13;23808:2;23800:6;23796:15;23789:38;23604:230;:::o;23840:366::-;23982:3;24003:67;24067:2;24062:3;24003:67;:::i;:::-;23996:74;;24079:93;24168:3;24079:93;:::i;:::-;24197:2;24192:3;24188:12;24181:19;;23840:366;;;:::o;24212:419::-;24378:4;24416:2;24405:9;24401:18;24393:26;;24465:9;24459:4;24455:20;24451:1;24440:9;24436:17;24429:47;24493:131;24619:4;24493:131;:::i;:::-;24485:139;;24212:419;;;:::o;24637:194::-;24677:4;24697:20;24715:1;24697:20;:::i;:::-;24692:25;;24731:20;24749:1;24731:20;:::i;:::-;24726:25;;24775:1;24772;24768:9;24760:17;;24799:1;24793:4;24790:11;24787:37;;;24804:18;;:::i;:::-;24787:37;24637:194;;;;:::o;24837:180::-;24885:77;24882:1;24875:88;24982:4;24979:1;24972:15;25006:4;25003:1;24996:15;25023:180;25071:77;25068:1;25061:88;25168:4;25165:1;25158:15;25192:4;25189:1;25182:15;25209:180;25257:77;25254:1;25247:88;25354:4;25351:1;25344:15;25378:4;25375:1;25368:15;25395:174;25535:26;25531:1;25523:6;25519:14;25512:50;25395:174;:::o;25575:366::-;25717:3;25738:67;25802:2;25797:3;25738:67;:::i;:::-;25731:74;;25814:93;25903:3;25814:93;:::i;:::-;25932:2;25927:3;25923:12;25916:19;;25575:366;;;:::o;25947:419::-;26113:4;26151:2;26140:9;26136:18;26128:26;;26200:9;26194:4;26190:20;26186:1;26175:9;26171:17;26164:47;26228:131;26354:4;26228:131;:::i;:::-;26220:139;;25947:419;;;:::o;26372:181::-;26512:33;26508:1;26500:6;26496:14;26489:57;26372:181;:::o;26559:366::-;26701:3;26722:67;26786:2;26781:3;26722:67;:::i;:::-;26715:74;;26798:93;26887:3;26798:93;:::i;:::-;26916:2;26911:3;26907:12;26900:19;;26559:366;;;:::o;26931:419::-;27097:4;27135:2;27124:9;27120:18;27112:26;;27184:9;27178:4;27174:20;27170:1;27159:9;27155:17;27148:47;27212:131;27338:4;27212:131;:::i;:::-;27204:139;;26931:419;;;:::o;27356:221::-;27496:34;27492:1;27484:6;27480:14;27473:58;27565:4;27560:2;27552:6;27548:15;27541:29;27356:221;:::o;27583:366::-;27725:3;27746:67;27810:2;27805:3;27746:67;:::i;:::-;27739:74;;27822:93;27911:3;27822:93;:::i;:::-;27940:2;27935:3;27931:12;27924:19;;27583:366;;;:::o;27955:419::-;28121:4;28159:2;28148:9;28144:18;28136:26;;28208:9;28202:4;28198:20;28194:1;28183:9;28179:17;28172:47;28236:131;28362:4;28236:131;:::i;:::-;28228:139;;27955:419;;;:::o;28380:77::-;28417:7;28446:5;28435:16;;28380:77;;;:::o;28463:118::-;28550:24;28568:5;28550:24;:::i;:::-;28545:3;28538:37;28463:118;;:::o;28587:112::-;28670:22;28686:5;28670:22;:::i;:::-;28665:3;28658:35;28587:112;;:::o;28705:545::-;28878:4;28916:3;28905:9;28901:19;28893:27;;28930:71;28998:1;28987:9;28983:17;28974:6;28930:71;:::i;:::-;29011:68;29075:2;29064:9;29060:18;29051:6;29011:68;:::i;:::-;29089:72;29157:2;29146:9;29142:18;29133:6;29089:72;:::i;:::-;29171;29239:2;29228:9;29224:18;29215:6;29171:72;:::i;:::-;28705:545;;;;;;;:::o

ipfs://ea4e88e7cc1b838001d6888316ead4c81583e68813269c2f8c086427ffe6b20a