Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at uniscan.xyz on 2025-07-28
*/

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


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

pragma solidity ^0.8.0;

/**
 * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 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 functionCall(target, data, "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");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason 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 {
            // 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

                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 v4.4.1 (proxy/utils/Initializable.sol)

pragma solidity ^0.8.0;


/**
 * @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 a proxied contract can't have 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.
 *
 * 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 initialize the implementation contract, you can either invoke the
 * initializer manually, or you can include a constructor to automatically mark it as initialized when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() initializer {}
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

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

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        // If the contract is initializing we ignore whether _initialized is set in order to support multiple
        // inheritance patterns, but we only do this in the context of a constructor, because in other contexts the
        // contract may have been reentered.
        require(_initializing ? _isConstructor() : !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }

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

    function _isConstructor() private view returns (bool) {
        return !AddressUpgradeable.isContract(address(this));
    }
}

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

    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;
    }
    uint256[50] private __gap;
}

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


// OpenZeppelin Contracts v4.4.1 (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 {
        __Context_init_unchained();
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal onlyInitializing {
        _transferOwnership(_msgSender());
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        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);
    }
    uint256[49] private __gap;
}

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


// OpenZeppelin Contracts v4.4.0 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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 `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, 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 `sender` to `recipient` 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 sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

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

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


// OpenZeppelin Contracts v4.4.0 (utils/Address.sol)

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 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 functionCall(target, data, "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");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason 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 {
            // 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

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


// OpenZeppelin Contracts v4.4.0 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;



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

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

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

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: @openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol


// OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)

pragma solidity ^0.8.0;



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

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

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    function __Pausable_init() internal onlyInitializing {
        __Context_init_unchained();
        __Pausable_init_unchained();
    }

    function __Pausable_init_unchained() internal onlyInitializing {
        _paused = false;
    }

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library StringsUpgradeable {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @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] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

// File: @openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol


// OpenZeppelin Contracts v4.4.1 (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 ECDSAUpgradeable {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    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");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' 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) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        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.
            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 if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } 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;
        uint8 v;
        assembly {
            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
            v := add(shr(255, vs), 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 (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // 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", StringsUpgradeable.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: @openzeppelin/contracts-upgradeable/interfaces/IERC1271Upgradeable.sol


// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1271.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC1271 standard signature validation method for
 * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
 *
 * _Available since v4.1._
 */
interface IERC1271Upgradeable {
    /**
     * @dev Should return whether the signature provided is valid for the provided data
     * @param hash      Hash of the data to be signed
     * @param signature Signature byte array associated with _data
     */
    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}

// File: @openzeppelin/contracts-upgradeable/utils/cryptography/SignatureCheckerUpgradeable.sol


// OpenZeppelin Contracts v4.4.1 (utils/cryptography/SignatureChecker.sol)

pragma solidity ^0.8.0;




/**
 * @dev Signature verification helper: Provide a single mechanism to verify both private-key (EOA) ECDSA signature and
 * ERC1271 contract signatures. Using this instead of ECDSA.recover in your contract will make them compatible with
 * smart contract wallets such as Argent and Gnosis.
 *
 * Note: unlike ECDSA signatures, contract signature's are revocable, and the outcome of this function can thus change
 * through time. It could return true at block N and false at block N+1 (or the opposite).
 *
 * _Available since v4.1._
 */
library SignatureCheckerUpgradeable {
    function isValidSignatureNow(
        address signer,
        bytes32 hash,
        bytes memory signature
    ) internal view returns (bool) {
        (address recovered, ECDSAUpgradeable.RecoverError error) = ECDSAUpgradeable.tryRecover(hash, signature);
        if (error == ECDSAUpgradeable.RecoverError.NoError && recovered == signer) {
            return true;
        }

        (bool success, bytes memory result) = signer.staticcall(
            abi.encodeWithSelector(IERC1271Upgradeable.isValidSignature.selector, hash, signature)
        );
        return (success && result.length == 32 && abi.decode(result, (bytes4)) == IERC1271Upgradeable.isValidSignature.selector);
    }
}

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


// OpenZeppelin Contracts v4.4.0 (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File: contracts/libraries/UniversalERC20New.sol


pragma solidity ^0.8.0;




library UniversalERC20 {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    IERC20 internal constant ZERO_ADDRESS = IERC20(0x0000000000000000000000000000000000000000);
    IERC20 internal constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
    IERC20 internal constant MATIC_ADDRESS = IERC20(0x0000000000000000000000000000000000001010);

    function universalTransfer(
        IERC20 token,
        address payable to,
        uint256 amount
    ) internal {
        if (amount > 0) {
            if (isETH(token)) {
                (bool result, ) = to.call{value: amount}("");
                require(result, "Failed to transfer ETH");
            } else {
                token.safeTransfer(to, amount);
            }
        }
    }

    function universalApprove(
        IERC20 token,
        address to,
        uint256 amount
    ) internal {
        require(!isETH(token), "Approve called on ETH");

        if (amount == 0) {
            token.safeApprove(to, 0);
        } else {
            uint256 allowance = token.allowance(address(this), to);
            if (allowance < amount) {
                if (allowance > 0) {
                    token.safeApprove(to, 0);
                }
                token.safeApprove(to, amount);
            }
        }
    }

    function universalBalanceOf(IERC20 token, address account) internal view returns (uint256) {
        if (isETH(token)) {
            return account.balance;
        } else {
            return token.balanceOf(account);
        }
    }

    function isETH(IERC20 token) internal pure returns (bool) {
        return
            address(token) == address(ETH_ADDRESS) ||
            address(token) == address(MATIC_ADDRESS) ||
            address(token) == address(ZERO_ADDRESS);
    }
}

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


// OpenZeppelin Contracts v4.4.0 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

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

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

// File: contracts/libraries/RevertReasonParser.sol



pragma solidity 0.8.10;


/// @title Library that allows to parse unsuccessful arbitrary calls revert reasons.
/// See https://solidity.readthedocs.io/en/latest/control-structures.html#revert for details.
/// Note that we assume revert reason being abi-encoded as Error(string) so it may fail to parse reason
/// if structured reverts appear in the future.
///
/// All unsuccessful parsings get encoded as Unknown(data) string
library RevertReasonParser {
    bytes4 constant private _PANIC_SELECTOR = bytes4(keccak256("Panic(uint256)"));
    bytes4 constant private _ERROR_SELECTOR = bytes4(keccak256("Error(string)"));

    function parse(bytes memory data, string memory prefix) internal pure returns (string memory) {
        if (data.length >= 4) {
            bytes4 selector;

            assembly {  // solhint-disable-line no-inline-assembly
                selector := mload(add(data, 0x20))
            }

            // 68 = 4-byte selector + 32 bytes offset + 32 bytes length
            if (selector == _ERROR_SELECTOR && data.length >= 68) {
                uint256 offset;
                bytes memory reason;
                assembly {  // solhint-disable-line no-inline-assembly
                    // 36 = 32 bytes data length + 4-byte selector
                    offset := mload(add(data, 36))
                    reason := add(data, add(36, offset))
                }
                /*
                    revert reason is padded up to 32 bytes with ABI encoder: Error(string)
                    also sometimes there is extra 32 bytes of zeros padded in the end:
                    https://github.com/ethereum/solidity/issues/10170
                    because of that we can't check for equality and instead check
                    that offset + string length + extra 36 bytes is less than overall data length
                */
                require(data.length >= 36 + offset + reason.length, "Invalid revert reason");
                return string(abi.encodePacked(prefix, "Error(", reason, ")"));
            }
            // 36 = 4-byte selector + 32 bytes integer
            else if (selector == _PANIC_SELECTOR && data.length == 36) {
                uint256 code;
                assembly {  // solhint-disable-line no-inline-assembly
                    // 36 = 32 bytes data length + 4-byte selector
                    code := mload(add(data, 36))
                }
                return string(abi.encodePacked(prefix, "Panic(", _toHex(code), ")"));
            }
        }

        return string(abi.encodePacked(prefix, "Unknown(", _toHex(data), ")"));
    }

    function _toHex(uint256 value) private pure returns(string memory) {
        return _toHex(abi.encodePacked(value));
    }

    function _toHex(bytes memory data) private pure returns(string memory) {
        bytes16 alphabet = 0x30313233343536373839616263646566;
        bytes memory str = new bytes(2 + data.length * 2);
        str[0] = "0";
        str[1] = "x";
        for (uint256 i = 0; i < data.length; i++) {
            str[2 * i + 2] = alphabet[uint8(data[i] >> 4)];
            str[2 * i + 3] = alphabet[uint8(data[i] & 0x0f)];
        }
        return string(str);
    }
}

// File: contracts/libraries/PermitableNew.sol



pragma solidity 0.8.10;



/// @title Interface for DAI-style permits
interface IDaiLikePermit {
    function permit(
        address holder,
        address spender,
        uint256 nonce,
        uint256 expiry,
        bool allowed,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
}

/// @title SignatureTransfer
/// @notice Handles ERC20 token transfers through signature based actions
/// @dev Requires user's token approval on the Permit2 contract
interface IPermit2 {
    /// @notice The token and amount details for a transfer signed in the permit transfer signature
    struct TokenPermissions {
        // ERC20 token address
        address token;
        // the maximum amount that can be spent
        uint256 amount;
    }

    /// @notice The signed permit message for a single token transfer
    struct PermitTransferFrom {
        TokenPermissions permitted;
        // a unique value for every token owner's signature to prevent signature replays
        uint256 nonce;
        // deadline on the permit signature
        uint256 deadline;
    }

    /// @notice Specifies the recipient address and amount for batched transfers.
    /// @dev Recipients and amounts correspond to the index of the signed token permissions array.
    /// @dev Reverts if the requested amount is greater than the permitted signed amount.
    struct SignatureTransferDetails {
        // recipient address
        address to;
        // spender requested amount
        uint256 requestedAmount;
    }

    /// @notice A map from token owner address and a caller specified word index to a bitmap. Used to set bits in the bitmap to prevent against signature replay protection
    /// @dev Uses unordered nonces so that permit messages do not need to be spent in a certain order
    /// @dev The mapping is indexed first by the token owner, then by an index specified in the nonce
    /// @dev It returns a uint256 bitmap
    /// @dev The index, or wordPosition is capped at type(uint248).max
    function nonceBitmap(address, uint256) external view returns (uint256);

    /// @notice Transfers a token using a signed permit message
    /// @dev Reverts if the requested amount is greater than the permitted signed amount
    /// @param permit The permit data signed over by the owner
    /// @param owner The owner of the tokens to transfer
    /// @param transferDetails The spender's requested transfer details for the permitted token
    /// @param signature The signature to verify
    function permitTransferFrom(
        PermitTransferFrom memory permit,
        SignatureTransferDetails calldata transferDetails,
        address owner,
        bytes calldata signature
    ) external;

    /// @notice Returns the domain separator for the current chain.
    /// @dev Uses cached version if chainid and address are unchanged from construction.
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

contract Permitable {
    address public permit2;

    function permit2DomainSeperator() external view returns (bytes32) {
        return IPermit2(permit2).DOMAIN_SEPARATOR();
    }

    function _permit(address token, bytes calldata permit, address from) internal returns (bool) {
        if (permit.length > 0) {
            if (permit.length == 32 * 7 || permit.length == 32 * 8) {
                (bool success, bytes memory result) = _permit1(token, permit);
                if (!success) {
                    revert(RevertReasonParser.parse(result, "Permit failed: "));
                }
                return false;
            } else {
                (bool success, bytes memory result) = _permit2(permit, from);
                if (!success) {
                    revert(RevertReasonParser.parse(result, "Permit2 failed: "));
                }
                return true;
            }
        }
        return false;
    }

    function _isPermit2(bytes calldata permit) internal pure returns (bool) {
        return permit.length == 32 * 11 || permit.length == 32 * 12;
    }

    function _permit1(address token, bytes calldata permit) private returns (bool success, bytes memory result) {
        if (permit.length == 32 * 7) {
            // solhint-disable-next-line avoid-low-level-calls
            (success, result) = token.call(abi.encodePacked(IERC20Permit.permit.selector, permit));
        } else if (permit.length == 32 * 8) {
            // solhint-disable-next-line avoid-low-level-calls
            (success, result) = token.call(abi.encodePacked(IDaiLikePermit.permit.selector, permit));
        }
    }

    function _permit2(bytes calldata permit, address from) private returns (bool success, bytes memory result) {
        (, , address owner, ) = abi.decode(
            permit,
            (IPermit2.PermitTransferFrom, IPermit2.SignatureTransferDetails, address, bytes)
        );
        require(owner == from, "Permit2 denied");
        // solhint-disable-next-line avoid-low-level-calls
        (success, result) = permit2.call(abi.encodePacked(IPermit2.permitTransferFrom.selector, permit)); // TODO support batch permit
    }

    /// @notice Finds the next valid nonce for a user, starting from 0.
    /// @param owner The owner of the nonces
    /// @return nonce The first valid nonce starting from 0
    function permit2NextNonce(address owner) external view returns (uint256 nonce) {
        nonce = _permit2NextNonce(owner, 0, 0);
    }

    /// @notice Finds the next valid nonce for a user, after from a given nonce.
    /// @dev This can be helpful if you're signing multiple nonces in a row and need the next nonce to sign but the start one is still valid.
    /// @param owner The owner of the nonces
    /// @param start The nonce to start from
    /// @return nonce The first valid nonce after the given nonce
    function permit2NextNonceAfter(address owner, uint256 start) external view returns (uint256 nonce) {
        uint248 word = uint248(start >> 8);
        uint8 pos = uint8(start);
        if (pos == type(uint8).max) {
            // If the position is 255, we need to move to the next word
            word++;
            pos = 0;
        } else {
            // Otherwise, we just move to the next position
            pos++;
        }
        nonce = _permit2NextNonce(owner, word, pos);
    }

    /// @notice Finds the next valid nonce for a user, starting from a given word and position.
    /// @param owner The owner of the nonces
    /// @param word Word to start looking from
    /// @param pos Position inside the word to start looking from
    function _permit2NextNonce(address owner, uint248 word, uint8 pos) internal view returns (uint256 nonce) {
        while (true) {
            uint256 bitmap = IPermit2(permit2).nonceBitmap(owner, word);

            // Check if the bitmap is completely full
            if (bitmap == type(uint256).max) {
                // If so, move to the next word
                ++word;
                pos = 0;
                continue;
            }
            if (pos != 0) {
                // If the position is not 0, we need to shift the bitmap to ignore the bits before position
                bitmap = bitmap >> pos;
            }
            // Find the first zero bit in the bitmap
            while (bitmap & 1 == 1) {
                bitmap = bitmap >> 1;
                ++pos;
            }

            return _permit2NonceFromWordAndPos(word, pos);
        }
    }

    /// @notice Constructs a nonce from a word and a position inside the word
    /// @param word The word containing the nonce
    /// @param pos The position of the nonce inside the word
    /// @return nonce The nonce constructed from the word and position
    function _permit2NonceFromWordAndPos(uint248 word, uint8 pos) internal pure returns (uint256 nonce) {
        // The last 248 bits of the word are the nonce bits
        nonce = uint256(word) << 8;
        // The first 8 bits of the word are the position inside the word
        nonce |= pos;
    }

}

// File: contracts/OpenOceanSettler.sol


pragma solidity ^0.8.10;









contract OpenOceanSettler is OwnableUpgradeable, PausableUpgradeable, Permitable {
    
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    using UniversalERC20 for IERC20;

    event AddAggregator(address aggregator);
    event DelAggregator(address aggregator);
    event SetFeeReceiver(address feeReceiver);
    event OSwap(address indexed from, bytes32 indexed orderHash, address swapAddress, uint256 returnAmount);
 
    address payable public feeReceiver;
    mapping(address => bool) public aggregators;
    mapping(address => bool) public operators;

    struct SwapData {
        address payable from;
        IERC20[] path;
        uint256[] amounts;
        address swapAddress;
        bytes swapExtraData;
        bytes32 orderHash;
        bytes permit;
        uint256 flag;
    }

    function initialize(address payable _feeReceiver) public initializer {
        OwnableUpgradeable.__Ownable_init();
        PausableUpgradeable.__Pausable_init();
        setFeeReceiver(_feeReceiver);
    }

    receive() external payable {}

    modifier onlyOperator() {
        require(operators[msg.sender], "Operator: caller is not the operator");
        _;
    }

    function addAggregator(address[] calldata _aggregators) public onlyOwner {
        for (uint i = 0; i < _aggregators.length; i++) {
            require(
                _aggregators[i] != address(0),
                "aggregator is zero address"
            );
            aggregators[_aggregators[i]] = true;
            emit AddAggregator(_aggregators[i]);
        }
    }

    function delAggregator(address _aggregator) public onlyOwner {
        aggregators[_aggregator] = false;
        emit DelAggregator(_aggregator);
    }

    function setFeeReceiver(address payable _feeReceiver) public onlyOwner {
        feeReceiver = _feeReceiver;
        emit SetFeeReceiver(_feeReceiver);
    }  
    
    function batchSwap(
        SwapData[] calldata swaps
    ) public payable onlyOperator whenNotPaused returns (uint256[] memory) {
        uint256[] memory returnAmounts = new uint256[](swaps.length);
        for (uint i = 0; i < swaps.length; i++) {
            returnAmounts[i] = swap(swaps[i]);
        }
        return returnAmounts;
    }

    function swap(
        SwapData calldata data
    ) internal returns (uint256 returnAmount) {
        require(
            data.path.length == 2 && data.amounts.length == 3,
            "Invalid amounts length"
        );
        require(data.swapAddress != address(0), "SwapAddress is zero address");
        require(aggregators[data.swapAddress], "SwapAddress is not support");

        IERC20 srcToken = data.path[0];
        IERC20 dstToken = data.path[1];

        require(_claim(data.from, srcToken, data.permit),"Transfer is failed");
        require(srcToken.universalBalanceOf(address(this)) >= data.amounts[0], "Transfer is failed.");
        uint256 initialDstBalance = dstToken.universalBalanceOf(address(this));

        srcToken.universalApprove(data.swapAddress, data.amounts[0]);
        (bool success, ) = data.swapAddress.call{value: msg.value}(data.swapExtraData);
        //uint256 returnAmount = 0;
        
        if (!success) {
            uint256 gasFee = data.amounts[2];
            if (gasFee > 0) {
                srcToken.safeTransfer(feeReceiver, gasFee);
            }
            srcToken.safeTransfer(data.from, data.amounts[0].sub(gasFee));
        } else {
            returnAmount = dstToken.universalBalanceOf(address(this)).sub(initialDstBalance);
            
            require(returnAmount > 0, "Return amount is not zero");
            uint256 fee = data.amounts[1];
            if (data.flag == 1) {
                srcToken.universalTransfer(feeReceiver, fee);
            } else {
                dstToken.universalTransfer(feeReceiver, fee);
                returnAmount = returnAmount.sub(fee);
            }
            dstToken.universalTransfer(data.from, returnAmount);
        }
 
        emit OSwap(data.from, data.orderHash, data.swapAddress, returnAmount);
    }

    function _claim(
        address from,
        IERC20 token,
        bytes calldata permit
    ) private returns(bool){
        return _permit(address(token), permit, from);
    }

    function setPermit2(address _permit2) external onlyOwner {
        permit2 = _permit2;
    }

    function updateOperator(address _operator, bool on) public onlyOwner {
        operators[_operator] = on;
    }

    function withdraw(
        IERC20 token,
        address payable receiver,
        uint256 amount
    ) public onlyOwner {
        token.universalTransfer(receiver, amount);
    }

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

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"aggregator","type":"address"}],"name":"AddAggregator","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"aggregator","type":"address"}],"name":"DelAggregator","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"indexed":false,"internalType":"address","name":"swapAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"returnAmount","type":"uint256"}],"name":"OSwap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"feeReceiver","type":"address"}],"name":"SetFeeReceiver","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address[]","name":"_aggregators","type":"address[]"}],"name":"addAggregator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"aggregators","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address payable","name":"from","type":"address"},{"internalType":"contract IERC20[]","name":"path","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"address","name":"swapAddress","type":"address"},{"internalType":"bytes","name":"swapExtraData","type":"bytes"},{"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"internalType":"bytes","name":"permit","type":"bytes"},{"internalType":"uint256","name":"flag","type":"uint256"}],"internalType":"struct OpenOceanSettler.SwapData[]","name":"swaps","type":"tuple[]"}],"name":"batchSwap","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_aggregator","type":"address"}],"name":"delAggregator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeReceiver","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"_feeReceiver","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"operators","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"permit2","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"permit2DomainSeperator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"permit2NextNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"}],"name":"permit2NextNonceAfter","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"_feeReceiver","type":"address"}],"name":"setFeeReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_permit2","type":"address"}],"name":"setPermit2","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"},{"internalType":"bool","name":"on","type":"bool"}],"name":"updateOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address payable","name":"receiver","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

69093:4933:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73473:94;;;;;;;;;;-1:-1:-1;73473:94:0;;;;;:::i;:::-;;:::i;:::-;;69587:43;;;;;;;;;;-1:-1:-1;69587:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;567:14:1;;560:22;542:41;;530:2;515:18;69587:43:0;;;;;;;;63849:22;;;;;;;;;;-1:-1:-1;63849:22:0;;;;-1:-1:-1;;;;;63849:22:0;;;;;;-1:-1:-1;;;;;758:32:1;;;740:51;;728:2;713:18;63849:22:0;594:203:1;69637:41:0;;;;;;;;;;-1:-1:-1;69637:41:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;70324:382;;;;;;;;;;-1:-1:-1;70324:382:0;;;;;:::i;:::-;;:::i;73958:65::-;;;;;;;;;;;;;:::i;30832:86::-;;;;;;;;;;-1:-1:-1;30903:7:0;;;;30832:86;;73575:113;;;;;;;;;;-1:-1:-1;73575:113:0;;;;;:::i;:::-;;:::i;13556:103::-;;;;;;;;;;;;;:::i;63880:128::-;;;;;;;;;;;;;:::i;:::-;;;2272:25:1;;;2260:2;2245:18;63880:128:0;2126:177:1;73889:61:0;;;;;;;;;;;;;:::i;12905:87::-;;;;;;;;;;-1:-1:-1;12978:6:0;;-1:-1:-1;;;;;12978:6:0;12905:87;;71050:351;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;69546:34::-;;;;;;;;;;-1:-1:-1;69546:34:0;;;;-1:-1:-1;;;;;69546:34:0;;;66752:506;;;;;;;;;;-1:-1:-1;66752:506:0;;;;;:::i;:::-;;:::i;69936:210::-;;;;;;;;;;-1:-1:-1;69936:210:0;;;;;:::i;:::-;;:::i;73696:185::-;;;;;;;;;;-1:-1:-1;73696:185:0;;;;;:::i;:::-;;:::i;70714:154::-;;;;;;;;;;-1:-1:-1;70714:154:0;;;;;:::i;:::-;;:::i;70876:160::-;;;;;;;;;;-1:-1:-1;70876:160:0;;;;;:::i;:::-;;:::i;13814:201::-;;;;;;;;;;-1:-1:-1;13814:201:0;;;;;:::i;:::-;;:::i;66224:136::-;;;;;;;;;;-1:-1:-1;66224:136:0;;;;;:::i;:::-;;:::i;73473:94::-;12978:6;;-1:-1:-1;;;;;12978:6:0;11425:10;13125:23;13117:68;;;;-1:-1:-1;;;13117:68:0;;;;;;;:::i;:::-;;;;;;;;;73541:7:::1;:18:::0;;-1:-1:-1;;;;;;73541:18:0::1;-1:-1:-1::0;;;;;73541:18:0;;;::::1;::::0;;;::::1;::::0;;73473:94::o;70324:382::-;12978:6;;-1:-1:-1;;;;;12978:6:0;11425:10;13125:23;13117:68;;;;-1:-1:-1;;;13117:68:0;;;;;;;:::i;:::-;70413:6:::1;70408:291;70425:23:::0;;::::1;70408:291;;;70523:1;70496:12:::0;;70509:1;70496:15;;::::1;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;70496:29:0::1;;;70470:117;;;::::0;-1:-1:-1;;;70470:117:0;;5579:2:1;70470:117:0::1;::::0;::::1;5561:21:1::0;5618:2;5598:18;;;5591:30;5657:28;5637:18;;;5630:56;5703:18;;70470:117:0::1;5377:350:1::0;70470:117:0::1;70633:4;70602:11;:28;70614:12;;70627:1;70614:15;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;70602:28:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;70602:28:0;:35;;-1:-1:-1;;70602:35:0::1;::::0;::::1;;::::0;;;::::1;::::0;;70657:30:::1;70671:12:::0;;70684:1;70671:15;;::::1;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;70657:30;::::0;-1:-1:-1;;;;;758:32:1;;;740:51;;728:2;713:18;70657:30:0::1;;;;;;;70450:3:::0;::::1;::::0;::::1;:::i;:::-;;;;70408:291;;;;70324:382:::0;;:::o;73958:65::-;12978:6;;-1:-1:-1;;;;;12978:6:0;11425:10;13125:23;13117:68;;;;-1:-1:-1;;;13117:68:0;;;;;;;:::i;:::-;74005:10:::1;:8;:10::i;:::-;73958:65::o:0;73575:113::-;12978:6;;-1:-1:-1;;;;;12978:6:0;11425:10;13125:23;13117:68;;;;-1:-1:-1;;;13117:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;73655:20:0;;;::::1;;::::0;;;:9:::1;:20;::::0;;;;:25;;-1:-1:-1;;73655:25:0::1;::::0;::::1;;::::0;;;::::1;::::0;;73575:113::o;13556:103::-;12978:6;;-1:-1:-1;;;;;12978:6:0;11425:10;13125:23;13117:68;;;;-1:-1:-1;;;13117:68:0;;;;;;;:::i;:::-;13621:30:::1;13648:1;13621:18;:30::i;63880:128::-:0;63973:7;;63964:36;;;-1:-1:-1;;;63964:36:0;;;;63937:7;;-1:-1:-1;;;;;63973:7:0;;63964:34;;:36;;;;;;;;;;;;;;63973:7;63964:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63957:43;;63880:128;:::o;73889:61::-;12978:6;;-1:-1:-1;;;;;12978:6:0;11425:10;13125:23;13117:68;;;;-1:-1:-1;;;13117:68:0;;;;;;;:::i;:::-;73934:8:::1;:6;:8::i;71050:351::-:0;70244:10;70234:21;;;;:9;:21;;;;;;71163:16;;70234:21;;70226:70;;;;-1:-1:-1;;;70226:70:0;;6395:2:1;70226:70:0;;;6377:21:1;6434:2;6414:18;;;6407:30;6473:34;6453:18;;;6446:62;-1:-1:-1;;;6524:18:1;;;6517:34;6568:19;;70226:70:0;6193:400:1;70226:70:0;30903:7;;;;31157:9:::1;31149:38;;;::::0;-1:-1:-1;;;31149:38:0;;6800:2:1;31149:38:0::1;::::0;::::1;6782:21:1::0;6839:2;6819:18;;;6812:30;-1:-1:-1;;;6858:18:1;;;6851:46;6914:18;;31149:38:0::1;6598:340:1::0;31149:38:0::1;71192:30:::2;71239:5:::0;71225:27:::2;::::0;::::2;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;-1:-1:-1;71225:27:0::2;;71192:60;;71268:6;71263:100;71280:16:::0;;::::2;71263:100;;;71337:14;71342:5;;71348:1;71342:8;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;71337:4;:14::i;:::-;71318:13;71332:1;71318:16;;;;;;;;:::i;:::-;;::::0;;::::2;::::0;;;;;:33;71298:3;::::2;::::0;::::2;:::i;:::-;;;;71263:100;;;-1:-1:-1::0;71380:13:0;-1:-1:-1;31198:1:0::2;71050:351:::0;;;;:::o;66752:506::-;66836:13;66894:1;66885:10;;;:5;66953:15;66946:22;;;;66942:255;;;67058:6;;;;:::i;:::-;;;;67085:1;67079:7;;66942:255;;;67180:5;;;;:::i;:::-;;;;66942:255;67215:35;67233:5;67240:4;67246:3;67215:17;:35::i;:::-;67207:43;66752:506;-1:-1:-1;;;;;66752:506:0:o;69936:210::-;9608:13;;;;;;;:48;;9644:12;;;;9643:13;9608:48;;;10411:4;1177:20;1225:8;9624:16;9600:107;;;;-1:-1:-1;;;9600:107:0;;8004:2:1;9600:107:0;;;7986:21:1;8043:2;8023:18;;;8016:30;8082:34;8062:18;;;8055:62;-1:-1:-1;;;8133:18:1;;;8126:44;8187:19;;9600:107:0;7802:410:1;9600:107:0;9720:19;9743:13;;;;;;9742:14;9767:101;;;;9802:13;:20;;-1:-1:-1;;9837:19:0;;;;;9767:101;70016:35:::1;:33;:35::i;:::-;70062:37;:35;:37::i;:::-;70110:28;70125:12;70110:14;:28::i;:::-;9898:14:::0;9894:68;;;9945:5;9929:21;;-1:-1:-1;;9929:21:0;;;9894:68;9315:654;69936:210;:::o;73696:185::-;12978:6;;-1:-1:-1;;;;;12978:6:0;11425:10;13125:23;13117:68;;;;-1:-1:-1;;;13117:68:0;;;;;;;:::i;:::-;73832:41:::1;-1:-1:-1::0;;;;;73832:23:0;::::1;73856:8:::0;73866:6;73832:23:::1;:41::i;70714:154::-:0;12978:6;;-1:-1:-1;;;;;12978:6:0;11425:10;13125:23;13117:68;;;;-1:-1:-1;;;13117:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;70786:24:0;::::1;70813:5;70786:24:::0;;;:11:::1;:24;::::0;;;;;;;;:32;;-1:-1:-1;;70786:32:0::1;::::0;;70834:26;;740:51:1;;;70834:26:0::1;::::0;713:18:1;70834:26:0::1;;;;;;;;70714:154:::0;:::o;70876:160::-;12978:6;;-1:-1:-1;;;;;12978:6:0;11425:10;13125:23;13117:68;;;;-1:-1:-1;;;13117:68:0;;;;;;;:::i;:::-;70958:11:::1;:26:::0;;-1:-1:-1;;;;;;70958:26:0::1;-1:-1:-1::0;;;;;70958:26:0;::::1;::::0;;::::1;::::0;;;71000:28:::1;::::0;740:51:1;;;71000:28:0::1;::::0;728:2:1;713:18;71000:28:0::1;594:203:1::0;13814:201:0;12978:6;;-1:-1:-1;;;;;12978:6:0;11425:10;13125:23;13117:68;;;;-1:-1:-1;;;13117:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;13903:22:0;::::1;13895:73;;;::::0;-1:-1:-1;;;13895:73:0;;8635:2:1;13895:73:0::1;::::0;::::1;8617:21:1::0;8674:2;8654:18;;;8647:30;8713:34;8693:18;;;8686:62;-1:-1:-1;;;8764:18:1;;;8757:36;8810:19;;13895:73:0::1;8433:402:1::0;13895:73:0::1;13979:28;13998:8;13979:18;:28::i;:::-;13814:201:::0;:::o;66224:136::-;66288:13;66322:30;66340:5;66347:1;66350;66322:17;:30::i;31891:120::-;30903:7;;;;31427:41;;;;-1:-1:-1;;;31427:41:0;;9042:2:1;31427:41:0;;;9024:21:1;9081:2;9061:18;;;9054:30;-1:-1:-1;;;9100:18:1;;;9093:50;9160:18;;31427:41:0;8840:344:1;31427:41:0;31950:7:::1;:15:::0;;-1:-1:-1;;31950:15:0::1;::::0;;31981:22:::1;11425:10:::0;31990:12:::1;31981:22;::::0;-1:-1:-1;;;;;758:32:1;;;740:51;;728:2;713:18;31981:22:0::1;;;;;;;31891:120::o:0;14175:191::-;14268:6;;;-1:-1:-1;;;;;14285:17:0;;;-1:-1:-1;;;;;;14285:17:0;;;;;;;14318:40;;14268:6;;;14285:17;14268:6;;14318:40;;14249:16;;14318:40;14238:128;14175:191;:::o;31632:118::-;30903:7;;;;31157:9;31149:38;;;;-1:-1:-1;;;31149:38:0;;6800:2:1;31149:38:0;;;6782:21:1;6839:2;6819:18;;;6812:30;-1:-1:-1;;;6858:18:1;;;6851:46;6914:18;;31149:38:0;6598:340:1;31149:38:0;31692:7:::1;:14:::0;;-1:-1:-1;;31692:14:0::1;31702:4;31692:14;::::0;;31722:20:::1;31729:12;11425:10:::0;;11345:98;71409:1863;71481:20;71536:9;;;;:4;:9;:::i;:::-;:16;;71556:1;71536:21;:49;;;;-1:-1:-1;71561:12:0;;;;:4;:12;:::i;:::-;:19;;71584:1;71561:24;71536:49;71514:121;;;;-1:-1:-1;;;71514:121:0;;10505:2:1;71514:121:0;;;10487:21:1;10544:2;10524:18;;;10517:30;-1:-1:-1;;;10563:18:1;;;10556:52;10625:18;;71514:121:0;10303:346:1;71514:121:0;71682:1;71654:16;;;;;;;;:::i;:::-;-1:-1:-1;;;;;71654:30:0;;;71646:70;;;;-1:-1:-1;;;71646:70:0;;10856:2:1;71646:70:0;;;10838:21:1;10895:2;10875:18;;;10868:30;10934:29;10914:18;;;10907:57;10981:18;;71646:70:0;10654:351:1;71646:70:0;71735:11;:29;71747:16;;;;;;;;:::i;:::-;-1:-1:-1;;;;;71735:29:0;;;;;;;;;;;;-1:-1:-1;71735:29:0;;;;71727:68;;;;-1:-1:-1;;;71727:68:0;;11212:2:1;71727:68:0;;;11194:21:1;11251:2;11231:18;;;11224:30;11290:28;11270:18;;;11263:56;11336:18;;71727:68:0;11010:350:1;71727:68:0;71808:15;71826:9;;;;:4;:9;:::i;:::-;71836:1;71826:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;71808:30;-1:-1:-1;71849:15:0;71867:9;;;;:4;:9;:::i;:::-;71877:1;71867:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;71849:30;-1:-1:-1;71900:40:0;71907:9;;;;:4;:9;:::i;:::-;71918:8;71928:11;;;;:4;:11;:::i;:::-;71900:6;:40::i;:::-;71892:70;;;;-1:-1:-1;;;71892:70:0;;12359:2:1;71892:70:0;;;12341:21:1;12398:2;12378:18;;;12371:30;-1:-1:-1;;;12417:18:1;;;12410:48;12475:18;;71892:70:0;12157:342:1;71892:70:0;72027:12;;;;:4;:12;:::i;:::-;72040:1;72027:15;;;;;;;:::i;:::-;;;;;;;71981:42;72017:4;71981:8;-1:-1:-1;;;;;71981:27:0;;;:42;;;;:::i;:::-;:61;;71973:93;;;;-1:-1:-1;;;71973:93:0;;12706:2:1;71973:93:0;;;12688:21:1;12745:2;12725:18;;;12718:30;-1:-1:-1;;;12764:18:1;;;12757:49;12823:18;;71973:93:0;12504:343:1;71973:93:0;72077:25;72105:42;-1:-1:-1;;;;;72105:27:0;;72141:4;72105:27;:42::i;:::-;72077:70;-1:-1:-1;72160:60:0;72186:16;;;;;;;;:::i;:::-;72204:12;;;;:4;:12;:::i;:::-;72217:1;72204:15;;;;;;;:::i;:::-;;;;;;;72160:8;-1:-1:-1;;;;;72160:25:0;;;:60;;;;;:::i;:::-;72232:12;72250:16;;;;;;;;:::i;:::-;-1:-1:-1;;;;;72250:21:0;72279:9;72290:18;;;;:4;:18;:::i;:::-;72250:59;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72231:78;;;72372:7;72367:815;;72396:14;72413:12;;;;:4;:12;:::i;:::-;72426:1;72413:15;;;;;;;:::i;:::-;;;;;;;72396:32;;72456:1;72447:6;:10;72443:93;;;72500:11;;72478:42;;-1:-1:-1;;;;;72478:21:0;;;;72500:11;72513:6;72478:21;:42::i;:::-;72550:61;72572:9;;;;:4;:9;:::i;:::-;72583:27;72603:6;72583:12;;;;:4;:12;:::i;:::-;72596:1;72583:15;;;;;;;:::i;:::-;;;;;;;:19;;:27;;;;:::i;:::-;-1:-1:-1;;;;;72550:21:0;;;:61;:21;:61::i;:::-;72381:242;72367:815;;;72659:65;72706:17;72659:42;-1:-1:-1;;;;;72659:27:0;;72695:4;72659:27;:42::i;:::-;:46;;:65::i;:::-;72644:80;;72776:1;72761:12;:16;72753:54;;;;-1:-1:-1;;;72753:54:0;;13330:2:1;72753:54:0;;;13312:21:1;13369:2;13349:18;;;13342:30;13408:27;13388:18;;;13381:55;13453:18;;72753:54:0;13128:349:1;72753:54:0;72822:11;72836:12;;;;:4;:12;:::i;:::-;72849:1;72836:15;;;;;;;:::i;:::-;;;;;;;72822:29;;72870:4;:9;;;72883:1;72870:14;72866:239;;;72932:11;;72905:44;;-1:-1:-1;;;;;72905:26:0;;;;72932:11;72945:3;72905:26;:44::i;:::-;72866:239;;;73017:11;;72990:44;;-1:-1:-1;;;;;72990:26:0;;;;73017:11;73030:3;72990:26;:44::i;:::-;73068:21;:12;73085:3;73068:16;:21::i;:::-;73053:36;;72866:239;73119:51;73146:9;;;;:4;:9;:::i;:::-;-1:-1:-1;;;;;73119:26:0;;;73157:12;73119:26;:51::i;:::-;72629:553;72367:815;73217:14;;;;73206:9;;;;73217:4;73206:9;:::i;:::-;-1:-1:-1;;;;;73200:64:0;;73233:16;;;;;;;;:::i;:::-;73200:64;;;-1:-1:-1;;;;;13674:32:1;;;13656:51;;13738:2;13723:18;;13716:34;;;13629:18;73200:64:0;;;;;;;71503:1769;;;;71409:1863;;;:::o;67524:896::-;67614:13;67640:773;67694:7;;67685:42;;-1:-1:-1;;;67685:42:0;;-1:-1:-1;;;;;13953:32:1;;;67685:42:0;;;13935:51:1;-1:-1:-1;;;;;14022:32:1;;14002:18;;;13995:60;67668:14:0;;67694:7;;67685:29;;13908:18:1;;67685:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67668:59;;-1:-1:-1;;67803:6:0;:27;67799:176;;;67900:6;;;:::i;:::-;;;67931:1;67925:7;;67951:8;;;67799:176;67993:8;;;;67989:180;;68140:13;;;;67989:180;68244:6;68253:1;68244:10;68258:1;68244:15;68237:103;;;68299:1;68289:11;68319:5;;;:::i;:::-;;;68237:103;;;-1:-1:-1;;68975:12:0;;;-1:-1:-1;;68889:1:0;68872:18;;;;68975:12;67640:773;67524:896;;;;;:::o;12569:134::-;10211:13;;;;;;;10203:69;;;;-1:-1:-1;;;10203:69:0;;;;;;;:::i;:::-;12632:26:::1;:24;:26::i;:::-;12669;:24;:26::i;30491:136::-:0;10211:13;;;;;;;10203:69;;;;-1:-1:-1;;;10203:69:0;;;;;;;:::i;:::-;30555:26:::1;:24;:26::i;:::-;30592:27;:25;:27::i;53589:408::-:0;53724:10;;53720:270;;53755:12;53761:5;53755;:12::i;:::-;53751:228;;;53789:11;53806:2;-1:-1:-1;;;;;53806:7:0;53821:6;53806:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53788:44;;;53859:6;53851:41;;;;-1:-1:-1;;;53851:41:0;;15079:2:1;53851:41:0;;;15061:21:1;15118:2;15098:18;;;15091:30;-1:-1:-1;;;15137:18:1;;;15130:52;15199:18;;53851:41:0;14877:346:1;53851:41:0;53769:139;70408:291:::1;70324:382:::0;;:::o;53751:228::-;53933:30;-1:-1:-1;;;;;53933:18:0;;53952:2;53956:6;53933:18;:30::i;73280:185::-;73397:4;73420:37;73436:5;73444:6;;73452:4;73420:7;:37::i;:::-;73413:44;;73280:185;;;;;;;:::o;54563:240::-;54645:7;54669:12;54675:5;54669;:12::i;:::-;54665:131;;;-1:-1:-1;;;;;;54705:15:0;;;54698:22;;54665:131;54760:24;;-1:-1:-1;;;54760:24:0;;-1:-1:-1;;;;;758:32:1;;;54760:24:0;;;740:51:1;54760:15:0;;;;;713:18:1;;54760:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54753:31;;;;54005:550;54136:12;54142:5;54136;:12::i;:::-;54135:13;54127:47;;;;-1:-1:-1;;;54127:47:0;;15430:2:1;54127:47:0;;;15412:21:1;15469:2;15449:18;;;15442:30;-1:-1:-1;;;15488:18:1;;;15481:51;15549:18;;54127:47:0;15228:345:1;54127:47:0;54191:11;54187:361;;54219:24;-1:-1:-1;;;;;54219:17:0;;54237:2;54241:1;54219:17;:24::i;54187:361::-;54296:34;;-1:-1:-1;;;54296:34:0;;54320:4;54296:34;;;15790::1;-1:-1:-1;;;;;15860:15:1;;;15840:18;;;15833:43;54276:17:0;;54296:15;;;;;;15725:18:1;;54296:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54276:54;;54361:6;54349:9;:18;54345:192;;;54392:13;;54388:86;;54430:24;-1:-1:-1;;;;;54430:17:0;;54448:2;54452:1;54430:17;:24::i;:::-;54492:29;-1:-1:-1;;;;;54492:17:0;;54510:2;54514:6;54492:17;:29::i;26149:211::-;26293:58;;-1:-1:-1;;;;;13674:32:1;;26293:58:0;;;13656:51:1;13723:18;;;13716:34;;;26266:86:0;;26286:5;;-1:-1:-1;;;26316:23:0;13629:18:1;;26293:58:0;;;;-1:-1:-1;;26293:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;26293:58:0;-1:-1:-1;;;;;;26293:58:0;;;;;;;;;;26266:19;:86::i;49325:98::-;49383:7;49410:5;49414:1;49410;:5;:::i;11269:70::-;10211:13;;;;;;;10203:69;;;;-1:-1:-1;;;10203:69:0;;;;;;;:::i;12711:113::-;10211:13;;;;;;;10203:69;;;;-1:-1:-1;;;10203:69:0;;;;;;;:::i;:::-;12784:32:::1;11425:10:::0;12784:18:::1;:32::i;30635:97::-:0;10211:13;;;;;;;10203:69;;;;-1:-1:-1;;;10203:69:0;;;;;;;:::i;:::-;30709:7:::1;:15:::0;;-1:-1:-1;;30709:15:0::1;::::0;;30635:97::o;54811:248::-;54863:4;-1:-1:-1;;;;;54900:38:0;;53439:42;54900:38;;:95;;-1:-1:-1;;;;;;54955:40:0;;53537:42;54955:40;54900:95;:151;;;-1:-1:-1;;;;;;;55012:39:0;;;54811:248::o;64016:766::-;64103:4;64124:17;;64120:632;;64179:6;64162:23;;;:50;;-1:-1:-1;64206:6:0;64189:23;;64162:50;64158:583;;;64234:12;64248:19;64271:23;64280:5;64287:6;;64271:8;:23::i;:::-;64233:61;;;;64318:7;64313:116;;64357:51;64382:6;64357:51;;;;;;;;;;;;;-1:-1:-1;;;64357:51:0;;;:24;:51::i;:::-;64350:59;;-1:-1:-1;;;64350:59:0;;;;;;;;:::i;64313:116::-;64454:5;64447:12;;;;;;64158:583;64501:12;64515:19;64538:22;64547:6;;64555:4;64538:8;:22::i;:::-;64500:60;;;;64584:7;64579:117;;64623:52;64648:6;64623:52;;;;;;;;;;;;;-1:-1:-1;;;64623:52:0;;;:24;:52::i;64579:117::-;64721:4;64714:11;;;;;;64158:583;-1:-1:-1;64769:5:0;64016:766;;;;;;:::o;26885:616::-;27249:10;;;27248:62;;-1:-1:-1;27265:39:0;;-1:-1:-1;;;27265:39:0;;27289:4;27265:39;;;15790:34:1;-1:-1:-1;;;;;15860:15:1;;;15840:18;;;15833:43;27265:15:0;;;;;15725:18:1;;27265:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;27248:62;27226:166;;;;-1:-1:-1;;;27226:166:0;;16870:2:1;27226:166:0;;;16852:21:1;16909:2;16889:18;;;16882:30;16948:34;16928:18;;;16921:62;-1:-1:-1;;;16999:18:1;;;16992:52;17061:19;;27226:166:0;16668:418:1;27226:166:0;27430:62;;-1:-1:-1;;;;;13674:32:1;;27430:62:0;;;13656:51:1;13723:18;;;13716:34;;;27403:90:0;;27423:5;;-1:-1:-1;;;27453:22:0;13629:18:1;;27430:62:0;13482:274:1;28722:716:0;29146:23;29172:69;29200:4;29172:69;;;;;;;;;;;;;;;;;29180:5;-1:-1:-1;;;;;29172:27:0;;;:69;;;;;:::i;:::-;29256:17;;29146:95;;-1:-1:-1;29256:21:0;29252:179;;29353:10;29342:30;;;;;;;;;;;;:::i;:::-;29334:85;;;;-1:-1:-1;;;29334:85:0;;17543:2:1;29334:85:0;;;17525:21:1;17582:2;17562:18;;;17555:30;17621:34;17601:18;;;17594:62;-1:-1:-1;;;17672:18:1;;;17665:40;17722:19;;29334:85:0;17341:406:1;64948:546:0;65021:12;65035:19;65088:6;65071:23;;65067:420;;;65206:54;;-1:-1:-1;;;;;65195:10:0;;;65206:54;;-1:-1:-1;;;65223:28:0;65253:6;;;;65206:54;;;:::i;:::-;;;;-1:-1:-1;;65206:54:0;;;;;;;;;;65195:66;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65175:86:0;;-1:-1:-1;65175:86:0;-1:-1:-1;65067:420:0;;;65300:6;65283:23;;65279:208;;;65418:56;;-1:-1:-1;;;;;65407:10:0;;;65418:56;;-1:-1:-1;;;65435:30:0;65467:6;;;;65418:56;;;:::i;:::-;;;;-1:-1:-1;;65418:56:0;;;;;;;;;;65407:68;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65387:88:0;;-1:-1:-1;65387:88:0;-1:-1:-1;65279:208:0;64948:546;;;;;;:::o;58129:2016::-;58208:13;58253:1;58238:4;:11;:16;58234:1821;;58403:4;58393:15;;58387:22;-1:-1:-1;;;;;;58517:27:0;;-1:-1:-1;;;58517:27:0;:48;;;;;58563:2;58548:4;:11;:17;;58517:48;58513:1531;;;58827:2;58817:13;;;58811:20;58863:26;;;;;59436:13;;58811:20;;58863:26;;59436:13;59422:11;;58811:20;;59422:11;:::i;:::-;:27;;;;:::i;:::-;59407:4;:11;:42;;59399:76;;;;-1:-1:-1;;;59399:76:0;;18739:2:1;59399:76:0;;;18721:21:1;18778:2;18758:18;;;18751:30;-1:-1:-1;;;18797:18:1;;;18790:51;18858:18;;59399:76:0;18537:345:1;59399:76:0;59525:6;59543;59508:47;;;;;;;;;:::i;:::-;;;;;;;;;;;;;59494:62;;;;;;;58513:1531;-1:-1:-1;;;;;;59651:27:0;;-1:-1:-1;;;59651:27:0;:48;;;;;59682:4;:11;59697:2;59682:17;59651:48;59647:397;;;59919:2;59909:13;;59903:20;59991:6;60009:12;59903:20;60009:6;:12::i;:::-;59974:53;;;;;;;;;:::i;:::-;;;;;;;;;;;;;59960:68;;;;;;59647:397;58256:1799;58234:1821;60098:6;60118:12;60125:4;60118:6;:12::i;:::-;60081:55;;;;;;;;;:::i;:::-;;;;;;;;;;;;;60067:70;;58129:2016;;;;:::o;65502:534::-;65574:12;65588:19;65574:12;65644:137;;;;65669:6;65644:137;:::i;:::-;65620:161;;;;;65809:4;-1:-1:-1;;;;;65800:13:0;:5;-1:-1:-1;;;;;65800:13:0;;65792:40;;;;-1:-1:-1;;;65792:40:0;;23992:2:1;65792:40:0;;;23974:21:1;24031:2;24011:18;;;24004:30;-1:-1:-1;;;24050:18:1;;;24043:44;24104:18;;65792:40:0;23790:338:1;65792:40:0;65923:7;;65936:62;;-1:-1:-1;;;;;65923:7:0;;;;65936:62;;-1:-1:-1;;;65953:36:0;65991:6;;;;65936:62;;;:::i;:::-;;;;-1:-1:-1;;65936:62:0;;;;;;;;;;65923:76;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65903:96:0;;;;-1:-1:-1;65502:534:0;-1:-1:-1;;;;;65502:534:0:o;20927:229::-;21064:12;21096:52;21118:6;21126:4;21132:1;21135:12;21096:21;:52::i;60153:124::-;60205:13;60238:31;60262:5;60245:23;;;;;;24262:19:1;;24306:2;24297:12;;24133:182;60245:23:0;;;;;;;;;;;;;60285:466;60464:11;;60341:13;;-1:-1:-1;;;60367:53:0;:16;;60464:15;;60478:1;60464:15;:::i;:::-;60460:19;;:1;:19;:::i;:::-;60450:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60450:30:0;;60431:49;;-1:-1:-1;;;60491:3:0;60495:1;60491:6;;;;;;;;:::i;:::-;;;;:12;-1:-1:-1;;;;;60491:12:0;;;;;;;;;-1:-1:-1;;;60514:3:0;60518:1;60514:6;;;;;;;;:::i;:::-;;;;:12;-1:-1:-1;;;;;60514:12:0;;;;;;;;;60542:9;60537:178;60561:4;:11;60557:1;:15;60537:178;;;60611:8;60637:1;60626:4;60631:1;60626:7;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;60626:7:0;:12;;:7;60620:19;60611:29;;;;;;;:::i;:::-;;;;60594:3;60598:5;60602:1;60598;:5;:::i;:::-;:9;;60606:1;60598:9;:::i;:::-;60594:14;;;;;;;;:::i;:::-;;;;:46;-1:-1:-1;;;;;60594:46:0;;;;;;;;;60672:8;60687:4;60692:1;60687:7;;;;;;;;:::i;:::-;;;;;;;;60697:4;60681:21;60672:31;;;;;;;:::i;:::-;;;;60655:3;60659:5;60663:1;60659;:5;:::i;:::-;:9;;60667:1;60659:9;:::i;:::-;60655:14;;;;;;;;:::i;:::-;;;;:48;-1:-1:-1;;;;;60655:48:0;;;;;;;;-1:-1:-1;60574:3:0;;;;:::i;:::-;;;;60537:178;;;-1:-1:-1;60739:3:0;60285:466;-1:-1:-1;;;60285:466:0:o;22047:510::-;22217:12;22275:5;22250:21;:30;;22242:81;;;;-1:-1:-1;;;22242:81:0;;24695:2:1;22242:81:0;;;24677:21:1;24734:2;24714:18;;;24707:30;24773:34;24753:18;;;24746:62;-1:-1:-1;;;24824:18:1;;;24817:36;24870:19;;22242:81:0;24493:402:1;22242:81:0;1177:20;;22334:60;;;;-1:-1:-1;;;22334:60:0;;25102:2:1;22334:60:0;;;25084:21:1;25141:2;25121:18;;;25114:30;25180:31;25160:18;;;25153:59;25229:18;;22334:60:0;24900:353:1;22334:60:0;22408:12;22422:23;22449:6;-1:-1:-1;;;;;22449:11:0;22468:5;22475:4;22449:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22407:73;;;;22498:51;22515:7;22524:10;22536:12;22498:16;:51::i;:::-;22491:58;22047:510;-1:-1:-1;;;;;;;22047:510:0:o;24733:712::-;24883:12;24912:7;24908:530;;;-1:-1:-1;24943:10:0;24936:17;;24908:530;25057:17;;:21;25053:374;;25255:10;25249:17;25316:15;25303:10;25299:2;25295:19;25288:44;25053:374;25398:12;25391:20;;-1:-1:-1;;;25391:20:0;;;;;;;;:::i;14:131:1:-;-1:-1:-1;;;;;89:31:1;;79:42;;69:70;;135:1;132;125:12;150:247;209:6;262:2;250:9;241:7;237:23;233:32;230:52;;;278:1;275;268:12;230:52;317:9;304:23;336:31;361:5;336:31;:::i;802:367::-;865:8;875:6;929:3;922:4;914:6;910:17;906:27;896:55;;947:1;944;937:12;896:55;-1:-1:-1;970:20:1;;1013:18;1002:30;;999:50;;;1045:1;1042;1035:12;999:50;1082:4;1074:6;1070:17;1058:29;;1142:3;1135:4;1125:6;1122:1;1118:14;1110:6;1106:27;1102:38;1099:47;1096:67;;;1159:1;1156;1149:12;1096:67;802:367;;;;;:::o;1174:437::-;1260:6;1268;1321:2;1309:9;1300:7;1296:23;1292:32;1289:52;;;1337:1;1334;1327:12;1289:52;1377:9;1364:23;1410:18;1402:6;1399:30;1396:50;;;1442:1;1439;1432:12;1396:50;1481:70;1543:7;1534:6;1523:9;1519:22;1481:70;:::i;:::-;1570:8;;1455:96;;-1:-1:-1;1174:437:1;-1:-1:-1;;;;1174:437:1:o;1616:118::-;1702:5;1695:13;1688:21;1681:5;1678:32;1668:60;;1724:1;1721;1714:12;1739:382;1804:6;1812;1865:2;1853:9;1844:7;1840:23;1836:32;1833:52;;;1881:1;1878;1871:12;1833:52;1920:9;1907:23;1939:31;1964:5;1939:31;:::i;:::-;1989:5;-1:-1:-1;2046:2:1;2031:18;;2018:32;2059:30;2018:32;2059:30;:::i;:::-;2108:7;2098:17;;;1739:382;;;;;:::o;2778:632::-;2949:2;3001:21;;;3071:13;;2974:18;;;3093:22;;;2920:4;;2949:2;3172:15;;;;3146:2;3131:18;;;2920:4;3215:169;3229:6;3226:1;3223:13;3215:169;;;3290:13;;3278:26;;3359:15;;;;3324:12;;;;3251:1;3244:9;3215:169;;;-1:-1:-1;3401:3:1;;2778:632;-1:-1:-1;;;;;;2778:632:1:o;3639:315::-;3707:6;3715;3768:2;3756:9;3747:7;3743:23;3739:32;3736:52;;;3784:1;3781;3774:12;3736:52;3823:9;3810:23;3842:31;3867:5;3842:31;:::i;:::-;3892:5;3944:2;3929:18;;;;3916:32;;-1:-1:-1;;;3639:315:1:o;4401:478::-;4500:6;4508;4516;4569:2;4557:9;4548:7;4544:23;4540:32;4537:52;;;4585:1;4582;4575:12;4537:52;4624:9;4611:23;4643:31;4668:5;4643:31;:::i;:::-;4693:5;-1:-1:-1;4750:2:1;4735:18;;4722:32;4763:33;4722:32;4763:33;:::i;:::-;4401:478;;4815:7;;-1:-1:-1;;;4869:2:1;4854:18;;;;4841:32;;4401:478::o;4884:356::-;5086:2;5068:21;;;5105:18;;;5098:30;5164:34;5159:2;5144:18;;5137:62;5231:2;5216:18;;4884:356::o;5245:127::-;5306:10;5301:3;5297:20;5294:1;5287:31;5337:4;5334:1;5327:15;5361:4;5358:1;5351:15;5732:127;5793:10;5788:3;5784:20;5781:1;5774:31;5824:4;5821:1;5814:15;5848:4;5845:1;5838:15;5864:135;5903:3;-1:-1:-1;;5924:17:1;;5921:43;;;5944:18;;:::i;:::-;-1:-1:-1;5991:1:1;5980:13;;5864:135::o;6004:184::-;6074:6;6127:2;6115:9;6106:7;6102:23;6098:32;6095:52;;;6143:1;6140;6133:12;6095:52;-1:-1:-1;6166:16:1;;6004:184;-1:-1:-1;6004:184:1:o;6943:127::-;7004:10;6999:3;6995:20;6992:1;6985:31;7035:4;7032:1;7025:15;7059:4;7056:1;7049:15;7075:326;7169:4;7227:11;7214:25;7321:3;7317:8;7306;7290:14;7286:29;7282:44;7262:18;7258:69;7248:97;;7341:1;7338;7331:12;7248:97;7362:33;;;;;7075:326;-1:-1:-1;;7075:326:1:o;7406:211::-;7445:3;-1:-1:-1;;;;;7516:14:1;;;7542:15;;;7539:41;;;7560:18;;:::i;:::-;7609:1;7596:15;;7406:211;-1:-1:-1;;;7406:211:1:o;7622:175::-;7659:3;7703:4;7696:5;7692:16;7732:4;7723:7;7720:17;7717:43;;;7740:18;;:::i;:::-;7789:1;7776:15;;7622:175;-1:-1:-1;;7622:175:1:o;9189:559::-;9296:4;9302:6;9362:11;9349:25;9456:2;9452:7;9441:8;9425:14;9421:29;9417:43;9397:18;9393:68;9383:96;;9475:1;9472;9465:12;9383:96;9502:33;;9554:20;;;-1:-1:-1;9597:18:1;9586:30;;9583:50;;;9629:1;9626;9619:12;9583:50;9662:4;9650:17;;-1:-1:-1;9713:1:1;9709:14;;;9693;9689:35;9679:46;;9676:66;;;9738:1;9735;9728:12;11631:521;11708:4;11714:6;11774:11;11761:25;11868:2;11864:7;11853:8;11837:14;11833:29;11829:43;11809:18;11805:68;11795:96;;11887:1;11884;11877:12;11795:96;11914:33;;11966:20;;;-1:-1:-1;12009:18:1;11998:30;;11995:50;;;12041:1;12038;12031:12;11995:50;12074:4;12062:17;;-1:-1:-1;12105:14:1;12101:27;;;12091:38;;12088:58;;;12142:1;12139;12132:12;12852:271;13035:6;13027;13022:3;13009:33;12991:3;13061:16;;13086:13;;;13061:16;12852:271;-1:-1:-1;12852:271:1:o;14255:407::-;14457:2;14439:21;;;14496:2;14476:18;;;14469:30;14535:34;14530:2;14515:18;;14508:62;-1:-1:-1;;;14601:2:1;14586:18;;14579:41;14652:3;14637:19;;14255:407::o;15887:125::-;15927:4;15955:1;15952;15949:8;15946:34;;;15960:18;;:::i;:::-;-1:-1:-1;15997:9:1;;15887:125::o;16017:258::-;16089:1;16099:113;16113:6;16110:1;16107:13;16099:113;;;16189:11;;;16183:18;16170:11;;;16163:39;16135:2;16128:10;16099:113;;;16230:6;16227:1;16224:13;16221:48;;;-1:-1:-1;;16265:1:1;16247:16;;16240:27;16017:258::o;16280:383::-;16429:2;16418:9;16411:21;16392:4;16461:6;16455:13;16504:6;16499:2;16488:9;16484:18;16477:34;16520:66;16579:6;16574:2;16563:9;16559:18;16554:2;16546:6;16542:15;16520:66;:::i;:::-;16647:2;16626:15;-1:-1:-1;;16622:29:1;16607:45;;;;16654:2;16603:54;;16280:383;-1:-1:-1;;16280:383:1:o;17091:245::-;17158:6;17211:2;17199:9;17190:7;17186:23;17182:32;17179:52;;;17227:1;17224;17217:12;17179:52;17259:9;17253:16;17278:28;17300:5;17278:28;:::i;17752:368::-;-1:-1:-1;;;;;;17947:33:1;;17935:46;;18024:6;18016;18012:1;18003:11;;17990:41;17917:3;18054:16;;18072:1;18050:24;18083:13;;;18050:24;17752:368;-1:-1:-1;;17752:368:1:o;18125:274::-;18254:3;18292:6;18286:13;18308:53;18354:6;18349:3;18342:4;18334:6;18330:17;18308:53;:::i;18404:128::-;18444:3;18475:1;18471:6;18468:1;18465:13;18462:39;;;18481:18;;:::i;:::-;-1:-1:-1;18517:9:1;;18404:128::o;18887:771::-;19266:3;19304:6;19298:13;19320:53;19366:6;19361:3;19354:4;19346:6;19342:17;19320:53;:::i;:::-;-1:-1:-1;;;19395:16:1;;;19420:23;;;19468:13;;19490:65;19468:13;19542:1;19531:13;;19524:4;19512:17;;19490:65;:::i;:::-;-1:-1:-1;;;19618:1:1;19574:20;;;;19610:10;;;19603:23;19650:1;19642:10;;18887:771;-1:-1:-1;;;;18887:771:1:o;19663:773::-;20044:3;20082:6;20076:13;20098:53;20144:6;20139:3;20132:4;20124:6;20120:17;20098:53;:::i;:::-;-1:-1:-1;;;20173:16:1;;;20198:23;;;20246:13;;20268:65;20246:13;20320:1;20309:13;;20302:4;20290:17;;20268:65;:::i;20441:775::-;20822:3;20860:6;20854:13;20876:53;20922:6;20917:3;20910:4;20902:6;20898:17;20876:53;:::i;:::-;-1:-1:-1;;;20951:16:1;;;20976:25;;;21026:13;;21048:65;21026:13;21100:1;21089:13;;21082:4;21070:17;;21048:65;:::i;:::-;-1:-1:-1;;;21176:1:1;21132:20;;;;21168:10;;;21161:23;21208:1;21200:10;;20441:775;-1:-1:-1;;;;20441:775:1:o;21221:253::-;21293:2;21287:9;21335:4;21323:17;;21370:18;21355:34;;21391:22;;;21352:62;21349:88;;;21417:18;;:::i;:::-;21453:2;21446:22;21221:253;:::o;21479:275::-;21550:2;21544:9;21615:2;21596:13;;-1:-1:-1;;21592:27:1;21580:40;;21650:18;21635:34;;21671:22;;;21632:62;21629:88;;;21697:18;;:::i;:::-;21733:2;21726:22;21479:275;;-1:-1:-1;21479:275:1:o;21759:558::-;21822:5;21870:4;21858:9;21853:3;21849:19;21845:30;21842:50;;;21888:1;21885;21878:12;21842:50;21921:4;21915:11;21965:4;21957:6;21953:17;22036:6;22024:10;22021:22;22000:18;21988:10;21985:34;21982:62;21979:88;;;22047:18;;:::i;:::-;22083:4;22076:24;22118:6;-1:-1:-1;22118:6:1;22148:23;;22180:33;22148:23;22180:33;:::i;:::-;22222:23;;22306:2;22291:18;;;22278:32;22261:15;;22254:57;;;;21759:558;;-1:-1:-1;21759:558:1:o;22322:1463::-;22503:6;22511;22519;22527;22571:9;22562:7;22558:23;22601:3;22597:2;22593:12;22590:32;;;22618:1;22615;22608:12;22590:32;22642:4;22638:2;22634:13;22631:33;;;22660:1;22657;22650:12;22631:33;;22686:22;;:::i;:::-;22731:54;22777:7;22766:9;22731:54;:::i;:::-;22724:5;22717:69;22805:4;22869:2;22858:9;22854:18;22841:32;22836:2;22829:5;22825:14;22818:56;22934:4;22923:9;22919:20;22906:34;22901:2;22894:5;22890:14;22883:58;22960:5;22950:15;;22984:65;23041:7;23034:4;23023:9;23019:20;22984:65;:::i;:::-;22974:75;;23101:3;23090:9;23086:19;23073:33;23058:48;;23115:33;23140:7;23115:33;:::i;:::-;23167:7;;-1:-1:-1;23225:3:1;23210:19;;23197:33;;23249:18;23279:14;;;23276:34;;;23306:1;23303;23296:12;23276:34;23344:6;23333:9;23329:22;23319:32;;23389:7;23382:4;23378:2;23374:13;23370:27;23360:55;;23411:1;23408;23401:12;23360:55;23447:2;23434:16;23469:2;23465;23462:10;23459:36;;;23475:18;;:::i;:::-;23517:53;23560:2;23541:13;;-1:-1:-1;;23537:27:1;23533:36;;23517:53;:::i;:::-;23504:66;;23593:2;23586:5;23579:17;23633:7;23628:2;23623;23619;23615:11;23611:20;23608:33;23605:53;;;23654:1;23651;23644:12;23605:53;23709:2;23704;23700;23696:11;23691:2;23684:5;23680:14;23667:45;23753:1;23748:2;23743;23736:5;23732:14;23728:23;23721:34;;23774:5;23764:15;;;;;22322:1463;;;;;;;:::o;24320:168::-;24360:7;24426:1;24422;24418:6;24414:14;24411:1;24408:21;24403:1;24396:9;24389:17;24385:45;24382:71;;;24433:18;;:::i;:::-;-1:-1:-1;24473:9:1;;24320:168::o

ipfs://d25feb6c7e8dcaf7aa89cd23e472b3d52e8ac7632ea219824a39591f0b4842d4