Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at lineascan.build/ on 2024-03-05
*/

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

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.2;

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

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

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

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


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.1 (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: @openzeppelin/contracts/utils/Address.sol


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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library 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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

    /**
     * @dev 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

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

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

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

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


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

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @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 (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract 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 {
        __Pausable_init_unchained();
    }

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

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

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

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

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

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

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

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

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

// File: contracts/interfaces/IOpenOceanCaller.sol


pragma solidity ^0.8.0;


interface IOpenOceanCaller {
    struct CallDescription {
        uint256 target;
        uint256 gasLimit;
        uint256 value;
        bytes data;
    }

    function makeCall(CallDescription memory desc) external;

    function makeCalls(CallDescription[] memory desc) external payable;
}

// File: contracts/libraries/RevertReasonParser.sol


pragma solidity ^0.8.0;

library RevertReasonParser {
    function parse(bytes memory data, string memory prefix) internal pure returns (string memory) {
        // https://solidity.readthedocs.io/en/latest/control-structures.html#revert
        // We assume that revert reason is abi-encoded as Error(string)

        // 68 = 4-byte selector 0x08c379a0 + 32 bytes offset + 32 bytes length
        if (data.length >= 68 && data[0] == "\x08" && data[1] == "\xc3" && data[2] == "\x79" && data[3] == "\xa0") {
            string memory reason;
            // solhint-disable no-inline-assembly
            assembly {
                // 68 = 32 bytes data length + 4-byte selector + 32 bytes offset
                reason := add(data, 68)
            }
            /*
                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 string length + extra 68 bytes is less than overall data length
            */
            require(data.length >= 68 + bytes(reason).length, "Invalid revert reason");
            return string(abi.encodePacked(prefix, "Error(", reason, ")"));
        }
        // 36 = 4-byte selector 0x4e487b71 + 32 bytes integer
        else if (data.length == 36 && data[0] == "\x4e" && data[1] == "\x48" && data[2] == "\x7b" && data[3] == "\x71") {
            uint256 code;
            // solhint-disable no-inline-assembly
            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()"));
    }

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

    function _toHex(bytes memory data) private pure returns (string memory) {
        bytes memory alphabet = "0123456789abcdef";
        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: @openzeppelin/contracts/utils/math/SafeMath.sol


// OpenZeppelin Contracts (last updated v4.6.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 subtraction 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/UniversalERC20.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: contracts/OpenOceanExchange.sol



pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;






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

    uint256 private constant _PARTIAL_FILL = 0x01;
    uint256 private constant _SHOULD_CLAIM = 0x02;

    struct SwapDescription {
        IERC20 srcToken;
        IERC20 dstToken;
        address srcReceiver;
        address dstReceiver;
        uint256 amount;
        uint256 minReturnAmount;
        uint256 guaranteedAmount;
        uint256 flags;
        address referrer;
        bytes permit;
    }

    event Swapped(
        address indexed sender,
        IERC20 indexed srcToken,
        IERC20 indexed dstToken,
        address dstReceiver,
        uint256 amount,
        uint256 spentAmount,
        uint256 returnAmount,
        uint256 minReturnAmount,
        uint256 guaranteedAmount,
        address referrer
    );

    function initialize() public initializer {
        OwnableUpgradeable.__Ownable_init();
        PausableUpgradeable.__Pausable_init();
    }

    function swap(
        IOpenOceanCaller caller,
        SwapDescription calldata desc,
        IOpenOceanCaller.CallDescription[] calldata calls
    ) external payable whenNotPaused returns (uint256 returnAmount) {
        require(desc.minReturnAmount > 0, "Min return should not be 0");
        require(calls.length > 0, "Call data should exist");

        uint256 flags = desc.flags;
        IERC20 srcToken = desc.srcToken;
        IERC20 dstToken = desc.dstToken;

        require(msg.value == (srcToken.isETH() ? desc.amount : 0), "Invalid msg.value");

        if (flags & _SHOULD_CLAIM != 0) {
            require(!srcToken.isETH(), "Claim token is ETH");
            _claim(srcToken, desc.srcReceiver, desc.amount, desc.permit);
        }

        address dstReceiver = (desc.dstReceiver == address(0)) ? msg.sender : desc.dstReceiver;
        uint256 initialSrcBalance = (flags & _PARTIAL_FILL != 0) ? srcToken.universalBalanceOf(msg.sender) : 0;
        uint256 initialDstBalance = dstToken.universalBalanceOf(dstReceiver);

        caller.makeCalls{value: msg.value}(calls);

        uint256 spentAmount = desc.amount;
        returnAmount = dstToken.universalBalanceOf(dstReceiver).sub(initialDstBalance);

        if (flags & _PARTIAL_FILL != 0) {
            spentAmount = initialSrcBalance.add(desc.amount).sub(srcToken.universalBalanceOf(msg.sender));
            require(returnAmount.mul(desc.amount) >= desc.minReturnAmount.mul(spentAmount), "Return amount is not enough");
        } else {
            require(returnAmount >= desc.minReturnAmount, "Return amount is not enough");
        }

        _emitSwapped(desc, srcToken, dstToken, dstReceiver, spentAmount, returnAmount);
    }

    function _emitSwapped(
        SwapDescription calldata desc,
        IERC20 srcToken,
        IERC20 dstToken,
        address dstReceiver,
        uint256 spentAmount,
        uint256 returnAmount
    ) private {
        emit Swapped(
            msg.sender,
            srcToken,
            dstToken,
            dstReceiver,
            desc.amount,
            spentAmount,
            returnAmount,
            desc.minReturnAmount,
            desc.guaranteedAmount,
            desc.referrer
        );
    }

    function _claim(IERC20 token, address dst, uint256 amount, bytes calldata permit) private {
        // TODO: Is it safe to call permit on tokens without implemented permit? Fallback will be called. Is it bad for proxies?

        if (permit.length == 32 * 7) {
            // solhint-disable-next-line avoid-low-level-calls
            (bool success, bytes memory result) = address(token).call(abi.encodeWithSelector(IERC20Permit.permit.selector, permit));
            if (!success) {
                revert(RevertReasonParser.parse(result, "Permit call failed: "));
            }
        }

        token.safeTransferFrom(msg.sender, dst, amount);
    }

    function rescueFunds(IERC20 token, uint256 amount) external onlyOwner {
        token.universalTransfer(payable(msg.sender), amount);
    }

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"contract IERC20","name":"srcToken","type":"address"},{"indexed":true,"internalType":"contract IERC20","name":"dstToken","type":"address"},{"indexed":false,"internalType":"address","name":"dstReceiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"spentAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"returnAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"minReturnAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"guaranteedAmount","type":"uint256"},{"indexed":false,"internalType":"address","name":"referrer","type":"address"}],"name":"Swapped","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"initialize","outputs":[],"stateMutability":"nonpayable","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":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"rescueFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IOpenOceanCaller","name":"caller","type":"address"},{"components":[{"internalType":"contract IERC20","name":"srcToken","type":"address"},{"internalType":"contract IERC20","name":"dstToken","type":"address"},{"internalType":"address","name":"srcReceiver","type":"address"},{"internalType":"address","name":"dstReceiver","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"minReturnAmount","type":"uint256"},{"internalType":"uint256","name":"guaranteedAmount","type":"uint256"},{"internalType":"uint256","name":"flags","type":"uint256"},{"internalType":"address","name":"referrer","type":"address"},{"internalType":"bytes","name":"permit","type":"bytes"}],"internalType":"struct OpenOceanExchange.SwapDescription","name":"desc","type":"tuple"},{"components":[{"internalType":"uint256","name":"target","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct IOpenOceanCaller.CallDescription[]","name":"calls","type":"tuple[]"}],"name":"swap","outputs":[{"internalType":"uint256","name":"returnAmount","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x60806040526004361061007b5760003560e01c80638456cb591161004e5780638456cb59146100f45780638da5cb5b1461010957806390411a3214610131578063f2fde38b1461015257600080fd5b80635c975abb14610080578063715018a6146100a857806378e3214f146100bf5780638129fc1c146100df575b600080fd5b34801561008c57600080fd5b5060655460ff1660405190151581526020015b60405180910390f35b3480156100b457600080fd5b506100bd610172565b005b3480156100cb57600080fd5b506100bd6100da36600461149c565b610186565b3480156100eb57600080fd5b506100bd6101a6565b34801561010057600080fd5b506100bd6102c4565b34801561011557600080fd5b506033546040516001600160a01b03909116815260200161009f565b61014461013f3660046114c8565b6102d4565b60405190815260200161009f565b34801561015e57600080fd5b506100bd61016d366004611578565b61069c565b61017a610712565b610184600061076c565b565b61018e610712565b6101a26001600160a01b03831633836107be565b5050565b600054610100900460ff16158080156101c65750600054600160ff909116105b806101e05750303b1580156101e0575060005460ff166001145b6102485760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b60648201526084015b60405180910390fd5b6000805460ff19166001179055801561026b576000805461ff0019166101001790555b61027361088d565b61027b6108bc565b80156102c1576000805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b50565b6102cc610712565b6101846108eb565b60006102de610945565b60008460a00135116103325760405162461bcd60e51b815260206004820152601a60248201527f4d696e2072657475726e2073686f756c64206e6f742062652030000000000000604482015260640161023f565b816103785760405162461bcd60e51b815260206004820152601660248201527510d85b1b0819185d18481cda1bdd5b1908195e1a5cdd60521b604482015260640161023f565b60e0840135600061038c6020870187611578565b905060006103a06040880160208901611578565b90506103b4826001600160a01b031661098b565b6103bf5760006103c5565b86608001355b34146104075760405162461bcd60e51b8152602060048201526011602482015270496e76616c6964206d73672e76616c756560781b604482015260640161023f565b600283161561049057610422826001600160a01b031661098b565b156104645760405162461bcd60e51b8152602060048201526012602482015271086d8c2d2da40e8ded6cadc40d2e6408aa8960731b604482015260640161023f565b6104908261047860608a0160408b01611578565b60808a013561048b6101208c018c611595565b6109da565b6000806104a360808a0160608b01611578565b6001600160a01b0316146104c6576104c16080890160608a01611578565b6104c8565b335b90506000600185166104db5760006104ee565b6104ee6001600160a01b03851633610b03565b905060006105056001600160a01b03851684610b03565b90508a6001600160a01b031663a8920d2b348b8b6040518463ffffffff1660e01b815260040161053692919061160c565b6000604051808303818588803b15801561054f57600080fd5b505af1158015610563573d6000803e3d6000fd5b5050505060808b0135905061058b826105856001600160a01b03881687610b03565b90610ba4565b9750600187161561062b576105ba6105ac6001600160a01b03881633610b03565b6105858560808f0135610bb0565b90506105ca60a08c013582610bbc565b6105d88960808e0135610bbc565b10156106265760405162461bcd60e51b815260206004820152601b60248201527f52657475726e20616d6f756e74206973206e6f7420656e6f7567680000000000604482015260640161023f565b61067f565b8a60a0013588101561067f5760405162461bcd60e51b815260206004820152601b60248201527f52657475726e20616d6f756e74206973206e6f7420656e6f7567680000000000604482015260640161023f565b61068d8b878787858d610bc8565b50505050505050949350505050565b6106a4610712565b6001600160a01b0381166107095760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161023f565b6102c18161076c565b6033546001600160a01b031633146101845760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161023f565b603380546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b8015610888576107cd8361098b565b15610874576000826001600160a01b03168260405160006040518083038185875af1925050503d806000811461081f576040519150601f19603f3d011682016040523d82523d6000602084013e610824565b606091505b505090508061086e5760405162461bcd60e51b815260206004820152601660248201527508cc2d2d8cac840e8de40e8e4c2dce6cccae4408aa8960531b604482015260640161023f565b50505050565b6108886001600160a01b0384168383610c79565b505050565b600054610100900460ff166108b45760405162461bcd60e51b815260040161023f906116e3565b610184610cdc565b600054610100900460ff166108e35760405162461bcd60e51b815260040161023f906116e3565b610184610d0c565b6108f3610945565b6065805460ff191660011790557f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a2586109283390565b6040516001600160a01b03909116815260200160405180910390a1565b60655460ff16156101845760405162461bcd60e51b815260206004820152601060248201526f14185d5cd8589b194e881c185d5cd95960821b604482015260640161023f565b60006001600160a01b03821673eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee14806109c257506001600160a01b038216611010145b806109d457506001600160a01b038216155b92915050565b60e0811415610ae757600080866001600160a01b031663d505accf60e01b8585604051602401610a0b92919061172e565b60408051601f198184030181529181526020820180516001600160e01b03166001600160e01b0319909416939093179092529051610a49919061176e565b6000604051808303816000865af19150503d8060008114610a86576040519150601f19603f3d011682016040523d82523d6000602084013e610a8b565b606091505b509150915081610ae457610acb816040518060400160405280601481526020017302832b936b4ba1031b0b636103330b4b632b21d160651b815250610d3f565b60405162461bcd60e51b815260040161023f919061178a565b50505b610afc6001600160a01b038616338686610fab565b5050505050565b6000610b0e8361098b565b15610b2457506001600160a01b038116316109d4565b6040516370a0823160e01b81526001600160a01b0383811660048301528416906370a082319060240160206040518083038186803b158015610b6557600080fd5b505afa158015610b79573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b9d91906117bd565b9392505050565b6000610b9d82846117ec565b6000610b9d8284611803565b6000610b9d828461181b565b836001600160a01b0316856001600160a01b0316336001600160a01b03167f76af224a143865a50b41496e1a73622698692c565c1214bc862f18e22d829c5e868a6080013587878d60a001358e60c001358f610100016020810190610c2d9190611578565b604080516001600160a01b03988916815260208101979097528601949094526060850192909252608084015260a083015290911660c082015260e00160405180910390a4505050505050565b6040516001600160a01b03831660248201526044810182905261088890849063a9059cbb60e01b906064015b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b031990931692909217909152610fe3565b600054610100900460ff16610d035760405162461bcd60e51b815260040161023f906116e3565b6101843361076c565b600054610100900460ff16610d335760405162461bcd60e51b815260040161023f906116e3565b6065805460ff19169055565b60606044835110158015610d78575082600081518110610d6157610d6161183a565b6020910101516001600160f81b031916600160fb1b145b8015610da9575082600181518110610d9257610d9261183a565b6020910101516001600160f81b03191660c360f81b145b8015610dda575082600281518110610dc357610dc361183a565b6020910101516001600160f81b031916607960f81b145b8015610e0b575082600381518110610df457610df461183a565b6020910101516001600160f81b031916600560fd1b145b15610e9557604483810180519091610e239190611803565b84511015610e6b5760405162461bcd60e51b815260206004820152601560248201527424b73b30b634b2103932bb32b93a103932b0b9b7b760591b604482015260640161023f565b8281604051602001610e7e929190611850565b6040516020818303038152906040529150506109d4565b82516024148015610ecb575082600081518110610eb457610eb461183a565b6020910101516001600160f81b031916602760f91b145b8015610efc575082600181518110610ee557610ee561183a565b6020910101516001600160f81b031916600960fb1b145b8015610f2d575082600281518110610f1657610f1661183a565b6020910101516001600160f81b031916607b60f81b145b8015610f5e575082600381518110610f4757610f4761183a565b6020910101516001600160f81b031916607160f81b145b15610f8357602483015182610f72826110b5565b604051602001610e7e92919061189f565b81604051602001610f9491906118d4565b604051602081830303815290604052905092915050565b6040516001600160a01b038085166024830152831660448201526064810182905261086e9085906323b872dd60e01b90608401610ca5565b6000611038826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166110e19092919063ffffffff16565b80519091501561088857808060200190518101906110569190611901565b6108885760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b606482015260840161023f565b60606109d4826040516020016110cd91815260200190565b6040516020818303038152906040526110f8565b60606110f08484600085611311565b949350505050565b60408051808201909152601081526f181899199a1a9b1b9c1cb0b131b232b360811b602082015281516060919060009061113390600261181b565b61113e906002611803565b67ffffffffffffffff81111561115657611156611923565b6040519080825280601f01601f191660200182016040528015611180576020820181803683370190505b509050600360fc1b8160008151811061119b5761119b61183a565b60200101906001600160f81b031916908160001a905350600f60fb1b816001815181106111ca576111ca61183a565b60200101906001600160f81b031916908160001a90535060005b8451811015611309578260048683815181106112025761120261183a565b016020015182516001600160f81b031990911690911c60f81c90811061122a5761122a61183a565b01602001516001600160f81b0319168261124583600261181b565b611250906002611803565b815181106112605761126061183a565b60200101906001600160f81b031916908160001a9053508285828151811061128a5761128a61183a565b602091010151815160f89190911c600f169081106112aa576112aa61183a565b01602001516001600160f81b031916826112c583600261181b565b6112d0906003611803565b815181106112e0576112e061183a565b60200101906001600160f81b031916908160001a9053508061130181611939565b9150506111e4565b509392505050565b6060824710156113725760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6044820152651c8818d85b1b60d21b606482015260840161023f565b600080866001600160a01b0316858760405161138e919061176e565b60006040518083038185875af1925050503d80600081146113cb576040519150601f19603f3d011682016040523d82523d6000602084013e6113d0565b606091505b50915091506113e1878383876113ec565b979650505050505050565b60608315611458578251611451576001600160a01b0385163b6114515760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640161023f565b50816110f0565b6110f0838381511561146d5781518083602001fd5b8060405162461bcd60e51b815260040161023f919061178a565b6001600160a01b03811681146102c157600080fd5b600080604083850312156114af57600080fd5b82356114ba81611487565b946020939093013593505050565b600080600080606085870312156114de57600080fd5b84356114e981611487565b9350602085013567ffffffffffffffff8082111561150657600080fd5b90860190610140828903121561151b57600080fd5b9093506040860135908082111561153157600080fd5b818701915087601f83011261154557600080fd5b81358181111561155457600080fd5b8860208260051b850101111561156957600080fd5b95989497505060200194505050565b60006020828403121561158a57600080fd5b8135610b9d81611487565b6000808335601e198436030181126115ac57600080fd5b83018035915067ffffffffffffffff8211156115c757600080fd5b6020019150368190038213156115dc57600080fd5b9250929050565b81835281816020850137506000828201602090810191909152601f909101601f19169091010190565b60208082528181018390526000906040808401600586901b8501820187855b888110156116d557878303603f190184528135368b9003607e1901811261165157600080fd5b8a018035845286810135878501528581013586850152608060608083013536849003601e1901811261168257600080fd5b8301803567ffffffffffffffff81111561169b57600080fd5b8036038513156116aa57600080fd5b83838901526116be848901828d85016115e3565b988b0198975050509388019350505060010161162b565b509098975050505050505050565b6020808252602b908201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960408201526a6e697469616c697a696e6760a81b606082015260800190565b6020815260006110f06020830184866115e3565b60005b8381101561175d578181015183820152602001611745565b8381111561086e5750506000910152565b60008251611780818460208701611742565b9190910192915050565b60208152600082518060208401526117a9816040850160208701611742565b601f01601f19169190910160400192915050565b6000602082840312156117cf57600080fd5b5051919050565b634e487b7160e01b600052601160045260246000fd5b6000828210156117fe576117fe6117d6565b500390565b60008219821115611816576118166117d6565b500190565b6000816000190483118215151615611835576118356117d6565b500290565b634e487b7160e01b600052603260045260246000fd5b60008351611862818460208801611742565b6508ae4e4dee4560d31b9083019081528351611885816006840160208801611742565b602960f81b60069290910191820152600701949350505050565b600083516118b1818460208801611742565b650a0c2dcd2c6560d31b9083019081528351611885816006840160208801611742565b600082516118e6818460208701611742565b68556e6b6e6f776e282960b81b920191825250600901919050565b60006020828403121561191357600080fd5b81518015158114610b9d57600080fd5b634e487b7160e01b600052604160045260246000fd5b600060001982141561194d5761194d6117d6565b506001019056fea264697066735822122045a21944aa79cc18d49b613c01923b2a70e46fac4b42f88048ffc688603bacdc64736f6c63430008090033

54436:4282:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41035:86;;;;;;;;;;-1:-1:-1;41106:7:0;;;;41035:86;;179:14:1;;172:22;154:41;;142:2;127:18;41035:86:0;;;;;;;;18857:103;;;;;;;;;;;;;:::i;:::-;;58503:141;;;;;;;;;;-1:-1:-1;58503:141:0;;;;;:::i;:::-;;:::i;55386:143::-;;;;;;;;;;;;;:::i;58652:63::-;;;;;;;;;;;;;:::i;18209:87::-;;;;;;;;;;-1:-1:-1;18282:6:0;;18209:87;;-1:-1:-1;;;;;18282:6:0;;;838:51:1;;826:2;811:18;18209:87:0;692:203:1;55537:1739:0;;;;;;:::i;:::-;;:::i;:::-;;;2142:25:1;;;2130:2;2115:18;55537:1739:0;1996:177:1;19115:201:0;;;;;;;;;;-1:-1:-1;19115:201:0;;;;;:::i;:::-;;:::i;18857:103::-;18095:13;:11;:13::i;:::-;18922:30:::1;18949:1;18922:18;:30::i;:::-;18857:103::o:0;58503:141::-;18095:13;:11;:13::i;:::-;58584:52:::1;-1:-1:-1::0;;;;;58584:23:0;::::1;58616:10;58629:6:::0;58584:23:::1;:52::i;:::-;58503:141:::0;;:::o;55386:143::-;11930:19;11953:13;;;;;;11952:14;;12000:34;;;;-1:-1:-1;12018:12:0;;12033:1;12018:12;;;;:16;12000:34;11999:108;;;-1:-1:-1;12079:4:0;1593:19;:23;;;12040:66;;-1:-1:-1;12089:12:0;;;;;:17;12040:66;11977:204;;;;-1:-1:-1;;;11977:204:0;;2640:2:1;11977:204:0;;;2622:21:1;2679:2;2659:18;;;2652:30;2718:34;2698:18;;;2691:62;-1:-1:-1;;;2769:18:1;;;2762:44;2823:19;;11977:204:0;;;;;;;;;12192:12;:16;;-1:-1:-1;;12192:16:0;12207:1;12192:16;;;12219:67;;;;12254:13;:20;;-1:-1:-1;;12254:20:0;;;;;12219:67;55438:35:::1;:33;:35::i;:::-;55484:37;:35;:37::i;:::-;12312:14:::0;12308:102;;;12359:5;12343:21;;-1:-1:-1;;12343:21:0;;;12384:14;;-1:-1:-1;3005:36:1;;12384:14:0;;2993:2:1;2978:18;12384:14:0;;;;;;;12308:102;11919:498;55386:143::o;58652:63::-;18095:13;:11;:13::i;:::-;58699:8:::1;:6;:8::i;55537:1739::-:0;55732:20;40640:19;:17;:19::i;:::-;55796:1:::1;55773:4;:20;;;:24;55765:63;;;::::0;-1:-1:-1;;;55765:63:0;;3254:2:1;55765:63:0::1;::::0;::::1;3236:21:1::0;3293:2;3273:18;;;3266:30;3332:28;3312:18;;;3305:56;3378:18;;55765:63:0::1;3052:350:1::0;55765:63:0::1;55847:16:::0;55839:51:::1;;;::::0;-1:-1:-1;;;55839:51:0;;3609:2:1;55839:51:0::1;::::0;::::1;3591:21:1::0;3648:2;3628:18;;;3621:30;-1:-1:-1;;;3667:18:1;;;3660:52;3729:18;;55839:51:0::1;3407:346:1::0;55839:51:0::1;55919:10;::::0;::::1;;55903:13;55958;;::::0;::::1;55919:4:::0;55958:13:::1;:::i;:::-;55940:31:::0;-1:-1:-1;55982:15:0::1;56000:13;::::0;;;::::1;::::0;::::1;;:::i;:::-;55982:31;;56048:16;:8;-1:-1:-1::0;;;;;56048:14:0::1;;:16::i;:::-;:34;;56081:1;56048:34;;;56067:4;:11;;;56048:34;56034:9;:49;56026:79;;;::::0;-1:-1:-1;;;56026:79:0;;4234:2:1;56026:79:0::1;::::0;::::1;4216:21:1::0;4273:2;4253:18;;;4246:30;-1:-1:-1;;;4292:18:1;;;4285:47;4349:18;;56026:79:0::1;4032:341:1::0;56026:79:0::1;54712:4;56122:21:::0;::::1;:26:::0;56118:182:::1;;56174:16;:8;-1:-1:-1::0;;;;;56174:14:0::1;;:16::i;:::-;56173:17;56165:48;;;::::0;-1:-1:-1;;;56165:48:0;;4580:2:1;56165:48:0::1;::::0;::::1;4562:21:1::0;4619:2;4599:18;;;4592:30;-1:-1:-1;;;4638:18:1;;;4631:48;4696:18;;56165:48:0::1;4378:342:1::0;56165:48:0::1;56228:60;56235:8:::0;56245:16:::1;::::0;;;::::1;::::0;::::1;;:::i;:::-;56263:11;::::0;::::1;;56276;;::::0;::::1;56263:4:::0;56276:11:::1;:::i;:::-;56228:6;:60::i;:::-;56312:19;::::0;56335:16:::1;::::0;;;::::1;::::0;::::1;;:::i;:::-;-1:-1:-1::0;;;;;56335:30:0::1;;56334:64;;56382:16;::::0;;;::::1;::::0;::::1;;:::i;:::-;56334:64;;;56369:10;56334:64;56312:86:::0;-1:-1:-1;56409:25:0::1;54660:4;56438:21:::0;::::1;56437:74;;56510:1;56437:74;;;56468:39;-1:-1:-1::0;;;;;56468:27:0;::::1;56496:10;56468:27;:39::i;:::-;56409:102:::0;-1:-1:-1;56522:25:0::1;56550:40;-1:-1:-1::0;;;;;56550:27:0;::::1;56578:11:::0;56550:27:::1;:40::i;:::-;56522:68;;56603:6;-1:-1:-1::0;;;;;56603:16:0::1;;56627:9;56638:5;;56603:41;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;;;56679:11:0::1;::::0;::::1;;::::0;-1:-1:-1;56716:63:0::1;56761:17:::0;56716:40:::1;-1:-1:-1::0;;;;;56716:27:0;::::1;56744:11:::0;56716:27:::1;:40::i;:::-;:44:::0;::::1;:63::i;:::-;56701:78:::0;-1:-1:-1;54660:4:0::1;56796:21:::0;::::1;:26:::0;56792:386:::1;;56853:79;56892:39;-1:-1:-1::0;;;;;56892:27:0;::::1;56920:10;56892:27;:39::i;:::-;56853:34;:17:::0;56875:11:::1;::::0;::::1;;56853:21;:34::i;:79::-;56839:93:::0;-1:-1:-1;56988:37:0::1;:20;::::0;::::1;;56839:93:::0;56988:24:::1;:37::i;:::-;56955:29;:12:::0;56972:11:::1;::::0;::::1;;56955:16;:29::i;:::-;:70;;56947:110;;;::::0;-1:-1:-1;;;56947:110:0;;7512:2:1;56947:110:0::1;::::0;::::1;7494:21:1::0;7551:2;7531:18;;;7524:30;7590:29;7570:18;;;7563:57;7637:18;;56947:110:0::1;7310:351:1::0;56947:110:0::1;56792:386;;;57114:4;:20;;;57098:12;:36;;57090:76;;;::::0;-1:-1:-1;;;57090:76:0;;7512:2:1;57090:76:0::1;::::0;::::1;7494:21:1::0;7551:2;7531:18;;;7524:30;7590:29;7570:18;;;7563:57;7637:18;;57090:76:0::1;7310:351:1::0;57090:76:0::1;57190:78;57203:4;57209:8;57219;57229:11;57242;57255:12;57190;:78::i;:::-;55754:1522;;;;;;;55537:1739:::0;;;;;;:::o;19115:201::-;18095:13;:11;:13::i;:::-;-1:-1:-1;;;;;19204:22:0;::::1;19196:73;;;::::0;-1:-1:-1;;;19196:73:0;;7868:2:1;19196:73:0::1;::::0;::::1;7850:21:1::0;7907:2;7887:18;;;7880:30;7946:34;7926:18;;;7919:62;-1:-1:-1;;;7997:18:1;;;7990:36;8043:19;;19196:73:0::1;7666:402:1::0;19196:73:0::1;19280:28;19299:8;19280:18;:28::i;18374:132::-:0;18282:6;;-1:-1:-1;;;;;18282:6:0;16329:10;18438:23;18430:68;;;;-1:-1:-1;;;18430:68:0;;8275:2:1;18430:68:0;;;8257:21:1;;;8294:18;;;8287:30;8353:34;8333:18;;;8326:62;8405:18;;18430:68:0;8073:356:1;19476:191:0;19569:6;;;-1:-1:-1;;;;;19586:17:0;;;-1:-1:-1;;;;;;19586:17:0;;;;;;;19619:40;;19569:6;;;19586:17;19569:6;;19619:40;;19550:16;;19619:40;19539:128;19476:191;:::o;52839:408::-;52974:10;;52970:270;;53005:12;53011:5;53005;:12::i;:::-;53001:228;;;53039:11;53056:2;-1:-1:-1;;;;;53056:7:0;53071:6;53056:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53038:44;;;53109:6;53101:41;;;;-1:-1:-1;;;53101:41:0;;8846:2:1;53101:41:0;;;8828:21:1;8885:2;8865:18;;;8858:30;-1:-1:-1;;;8904:18:1;;;8897:52;8966:18;;53101:41:0;8644:346:1;53101:41:0;53019:139;52839:408;;;:::o;53001:228::-;53183:30;-1:-1:-1;;;;;53183:18:0;;53202:2;53206:6;53183:18;:30::i;:::-;52839:408;;;:::o;17752:97::-;14073:13;;;;;;;14065:69;;;;-1:-1:-1;;;14065:69:0;;;;;;;:::i;:::-;17815:26:::1;:24;:26::i;40205:99::-:0;14073:13;;;;;;;14065:69;;;;-1:-1:-1;;;14065:69:0;;;;;;;:::i;:::-;40269:27:::1;:25;:27::i;41631:118::-:0;40640:19;:17;:19::i;:::-;41691:7:::1;:14:::0;;-1:-1:-1;;41691:14:0::1;41701:4;41691:14;::::0;;41721:20:::1;41728:12;16329:10:::0;;16249:98;41728:12:::1;41721:20;::::0;-1:-1:-1;;;;;856:32:1;;;838:51;;826:2;811:18;41721:20:0::1;;;;;;;41631:118::o:0;41194:108::-;41106:7;;;;41264:9;41256:38;;;;-1:-1:-1;;;41256:38:0;;9609:2:1;41256:38:0;;;9591:21:1;9648:2;9628:18;;;9621:30;-1:-1:-1;;;9667:18:1;;;9660:46;9723:18;;41256:38:0;9407:340:1;54061:248:0;54113:4;-1:-1:-1;;;;;54150:38:0;;52689:42;54150:38;;:95;;-1:-1:-1;;;;;;54205:40:0;;52787:42;54205:40;54150:95;:151;;;-1:-1:-1;;;;;;54262:39:0;;;54150:151;54130:171;54061:248;-1:-1:-1;;54061:248:0:o;57829:666::-;58083:6;58066:23;;58062:366;;;58171:12;58185:19;58216:5;-1:-1:-1;;;;;58208:19:0;58251:28;;;58281:6;;58228:60;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;58228:60:0;;;;;;;;;;;;;;-1:-1:-1;;;;;58228:60:0;-1:-1:-1;;;;;;58228:60:0;;;;;;;;;;58208:81;;;;58228:60;58208:81;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58170:119;;;;58309:7;58304:113;;58344:56;58369:6;58344:56;;;;;;;;;;;;;-1:-1:-1;;;58344:56:0;;;:24;:56::i;:::-;58337:64;;-1:-1:-1;;;58337:64:0;;;;;;;;:::i;58304:113::-;58091:337;;58062:366;58440:47;-1:-1:-1;;;;;58440:22:0;;58463:10;58475:3;58480:6;58440:22;:47::i;:::-;57829:666;;;;;:::o;53813:240::-;53895:7;53919:12;53925:5;53919;:12::i;:::-;53915:131;;;-1:-1:-1;;;;;;53955:15:0;;;53948:22;;53915:131;54010:24;;-1:-1:-1;;;54010:24:0;;-1:-1:-1;;;;;856:32:1;;;54010:24:0;;;838:51:1;54010:15:0;;;;;811:18:1;;54010:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54003:31;53813:240;-1:-1:-1;;;53813:240:0:o;48580:98::-;48638:7;48665:5;48669:1;48665;:5;:::i;48199:98::-;48257:7;48284:5;48288:1;48284;:5;:::i;48937:98::-;48995:7;49022:5;49026:1;49022;:5;:::i;57284:537::-;57590:8;-1:-1:-1;;;;;57520:293:0;57567:8;-1:-1:-1;;;;;57520:293:0;57542:10;-1:-1:-1;;;;;57520:293:0;;57613:11;57639:4;:11;;;57665;57691:12;57718:4;:20;;;57753:4;:21;;;57789:4;:13;;;;;;;;;;:::i;:::-;57520:293;;;-1:-1:-1;;;;;12059:15:1;;;12041:34;;12106:2;12091:18;;12084:34;;;;12134:18;;12127:34;;;;12192:2;12177:18;;12170:34;;;;12235:3;12220:19;;12213:35;12021:3;12264:19;;12257:35;12329:15;;;12323:3;12308:19;;12301:44;11990:3;11975:19;57520:293:0;;;;;;;57284:537;;;;;;:::o;35356:211::-;35500:58;;-1:-1:-1;;;;;12548:32:1;;35500:58:0;;;12530:51:1;12597:18;;;12590:34;;;35473:86:0;;35493:5;;-1:-1:-1;;;35523:23:0;12503:18:1;;35500:58:0;;;;-1:-1:-1;;35500:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;35500:58:0;-1:-1:-1;;;;;;35500:58:0;;;;;;;;;;35473:19;:86::i;17857:113::-;14073:13;;;;;;;14065:69;;;;-1:-1:-1;;;14065:69:0;;;;;;;:::i;:::-;17930:32:::1;16329:10:::0;17930:18:::1;:32::i;40312:97::-:0;14073:13;;;;;;;14065:69;;;;-1:-1:-1;;;14065:69:0;;;;;;;:::i;:::-;40386:7:::1;:15:::0;;-1:-1:-1;;40386:15:0::1;::::0;;40312:97::o;42826:1893::-;42905:13;43190:2;43175:4;:11;:17;;:38;;;;;43196:4;43201:1;43196:7;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;;;;;43196:7:0;-1:-1:-1;;;43196:17:0;43175:38;:59;;;;;43217:4;43222:1;43217:7;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;;;;;43217:7:0;-1:-1:-1;;;43217:17:0;43175:59;:80;;;;;43238:4;43243:1;43238:7;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;;;;;43238:7:0;-1:-1:-1;;;43238:17:0;43175:80;:101;;;;;43259:4;43264:1;43259:7;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;;;;;43259:7:0;-1:-1:-1;;;43259:17:0;43175:101;43171:1476;;;43509:2;43499:13;;;44005:20;;43499:13;;44000:25;;44005:20;44000:25;:::i;:::-;43985:4;:11;:40;;43977:74;;;;-1:-1:-1;;;43977:74:0;;12969:2:1;43977:74:0;;;12951:21:1;13008:2;12988:18;;;12981:30;-1:-1:-1;;;13027:18:1;;;13020:51;13088:18;;43977:74:0;12767:345:1;43977:74:0;44097:6;44115;44080:47;;;;;;;;;:::i;:::-;;;;;;;;;;;;;44066:62;;;;;43171:1476;44222:4;:11;44237:2;44222:17;:38;;;;;44243:4;44248:1;44243:7;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;;;;;44243:7:0;-1:-1:-1;;;44243:17:0;44222:38;:59;;;;;44264:4;44269:1;44264:7;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;;;;;44264:7:0;-1:-1:-1;;;44264:17:0;44222:59;:80;;;;;44285:4;44290:1;44285:7;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;;;;;44285:7:0;-1:-1:-1;;;44285:17:0;44222:80;:101;;;;;44306:4;44311:1;44306:7;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;;;;;44306:7:0;-1:-1:-1;;;44306:17:0;44222:101;44218:429;;;44534:2;44524:13;;44518:20;44598:6;44616:12;44518:20;44616:6;:12::i;:::-;44581:53;;;;;;;;;:::i;44218:429::-;44690:6;44673:37;;;;;;;;:::i;:::-;;;;;;;;;;;;;44659:52;;42826:1893;;;;:::o;35575:248::-;35746:68;;-1:-1:-1;;;;;15383:15:1;;;35746:68:0;;;15365:34:1;15435:15;;15415:18;;;15408:43;15467:18;;;15460:34;;;35719:96:0;;35739:5;;-1:-1:-1;;;35769:27:0;15300:18:1;;35746:68:0;15125:375:1;38423:716:0;38847:23;38873:69;38901:4;38873:69;;;;;;;;;;;;;;;;;38881:5;-1:-1:-1;;;;;38873:27:0;;;:69;;;;;:::i;:::-;38957:17;;38847:95;;-1:-1:-1;38957:21:0;38953:179;;39054:10;39043:30;;;;;;;;;;;;:::i;:::-;39035:85;;;;-1:-1:-1;;;39035:85:0;;15989:2:1;39035:85:0;;;15971:21:1;16028:2;16008:18;;;16001:30;16067:34;16047:18;;;16040:62;-1:-1:-1;;;16118:18:1;;;16111:40;16168:19;;39035:85:0;15787:406:1;44727:125:0;44780:13;44813:31;44837:5;44820:23;;;;;;16327:19:1;;16371:2;16362:12;;16198:182;44820:23:0;;;;;;;;;;;;;44813:6;:31::i;29206:229::-;29343:12;29375:52;29397:6;29405:4;29411:1;29414:12;29375:21;:52::i;:::-;29368:59;29206:229;-1:-1:-1;;;;29206:229:0:o;44860:456::-;44943:42;;;;;;;;;;;;-1:-1:-1;;;44943:42:0;;;;45029:11;;44917:13;;44943:42;:21;;45029:15;;45043:1;45029:15;:::i;:::-;45025:19;;:1;:19;:::i;:::-;45015:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45015:30:0;;44996:49;;-1:-1:-1;;;45056:3:0;45060:1;45056:6;;;;;;;;:::i;:::-;;;;:12;-1:-1:-1;;;;;45056:12:0;;;;;;;;;-1:-1:-1;;;45079:3:0;45083:1;45079:6;;;;;;;;:::i;:::-;;;;:12;-1:-1:-1;;;;;45079:12:0;;;;;;;;;45107:9;45102:178;45126:4;:11;45122:1;:15;45102:178;;;45176:8;45202:1;45191:4;45196:1;45191:7;;;;;;;;:::i;:::-;;;;;45176:29;;-1:-1:-1;;;;;;45191:7:0;;;:12;;;:7;45185:19;;45176:29;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;45176:29:0;45159:3;45163:5;45167:1;45163;:5;:::i;:::-;:9;;45171:1;45163:9;:::i;:::-;45159:14;;;;;;;;:::i;:::-;;;;:46;-1:-1:-1;;;;;45159:46:0;;;;;;;;;45237:8;45252:4;45257:1;45252:7;;;;;;;;:::i;:::-;;;;;;45237:31;;45252:7;;;;;45262:4;45246:21;;45237:31;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;45237:31:0;45220:3;45224:5;45228:1;45224;:5;:::i;:::-;:9;;45232:1;45224:9;:::i;:::-;45220:14;;;;;;;;:::i;:::-;;;;:48;-1:-1:-1;;;;;45220:48:0;;;;;;;;-1:-1:-1;45139:3:0;;;;:::i;:::-;;;;45102:178;;;-1:-1:-1;45304:3:0;44860:456;-1:-1:-1;;;44860:456:0:o;30326:455::-;30496:12;30554:5;30529:21;:30;;30521:81;;;;-1:-1:-1;;;30521:81:0;;16859:2:1;30521:81:0;;;16841:21:1;16898:2;16878:18;;;16871:30;16937:34;16917:18;;;16910:62;-1:-1:-1;;;16988:18:1;;;16981:36;17034:19;;30521:81:0;16657:402:1;30521:81:0;30614:12;30628:23;30655:6;-1:-1:-1;;;;;30655:11:0;30674:5;30681:4;30655:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30613:73;;;;30704:69;30731:6;30739:7;30748:10;30760:12;30704:26;:69::i;:::-;30697:76;30326:455;-1:-1:-1;;;;;;;30326:455:0:o;32899:644::-;33084:12;33113:7;33109:427;;;33141:17;;33137:290;;-1:-1:-1;;;;;1593:19:0;;;33351:60;;;;-1:-1:-1;;;33351:60:0;;17266:2:1;33351:60:0;;;17248:21:1;17305:2;17285:18;;;17278:30;17344:31;17324:18;;;17317:59;17393:18;;33351:60:0;17064:353:1;33351:60:0;-1:-1:-1;33448:10:0;33441:17;;33109:427;33491:33;33499:10;33511:12;34246:17;;:21;34242:388;;34478:10;34472:17;34535:15;34522:10;34518:2;34514:19;34507:44;34242:388;34605:12;34598:20;;-1:-1:-1;;;34598:20:0;;;;;;;;:::i;206:139:1:-;-1:-1:-1;;;;;289:31:1;;279:42;;269:70;;335:1;332;325:12;350:337;432:6;440;493:2;481:9;472:7;468:23;464:32;461:52;;;509:1;506;499:12;461:52;548:9;535:23;567:39;600:5;567:39;:::i;:::-;625:5;677:2;662:18;;;;649:32;;-1:-1:-1;;;350:337:1:o;900:1091::-;1099:6;1107;1115;1123;1176:2;1164:9;1155:7;1151:23;1147:32;1144:52;;;1192:1;1189;1182:12;1144:52;1231:9;1218:23;1250:39;1283:5;1250:39;:::i;:::-;1308:5;-1:-1:-1;1364:2:1;1349:18;;1336:32;1387:18;1417:14;;;1414:34;;;1444:1;1441;1434:12;1414:34;1467:22;;;;1523:3;1505:16;;;1501:26;1498:46;;;1540:1;1537;1530:12;1498:46;1563:2;;-1:-1:-1;1618:2:1;1603:18;;1590:32;;1634:16;;;1631:36;;;1663:1;1660;1653:12;1631:36;1701:8;1690:9;1686:24;1676:34;;1748:7;1741:4;1737:2;1733:13;1729:27;1719:55;;1770:1;1767;1760:12;1719:55;1810:2;1797:16;1836:2;1828:6;1825:14;1822:34;;;1852:1;1849;1842:12;1822:34;1905:7;1900:2;1890:6;1887:1;1883:14;1879:2;1875:23;1871:32;1868:45;1865:65;;;1926:1;1923;1916:12;1865:65;900:1091;;;;-1:-1:-1;;1957:2:1;1949:11;;-1:-1:-1;;;900:1091:1:o;2178:255::-;2237:6;2290:2;2278:9;2269:7;2265:23;2261:32;2258:52;;;2306:1;2303;2296:12;2258:52;2345:9;2332:23;2364:39;2397:5;2364:39;:::i;4725:521::-;4802:4;4808:6;4868:11;4855:25;4962:2;4958:7;4947:8;4931:14;4927:29;4923:43;4903:18;4899:68;4889:96;;4981:1;4978;4971:12;4889:96;5008:33;;5060:20;;;-1:-1:-1;5103:18:1;5092:30;;5089:50;;;5135:1;5132;5125:12;5089:50;5168:4;5156:17;;-1:-1:-1;5199:14:1;5195:27;;;5185:38;;5182:58;;;5236:1;5233;5226:12;5182:58;4725:521;;;;;:::o;5251:266::-;5339:6;5334:3;5327:19;5391:6;5384:5;5377:4;5372:3;5368:14;5355:43;-1:-1:-1;5443:1:1;5418:16;;;5436:4;5414:27;;;5407:38;;;;5499:2;5478:15;;;-1:-1:-1;;5474:29:1;5465:39;;;5461:50;;5251:266::o;5522:1783::-;5771:2;5823:21;;;5796:18;;;5879:22;;;5742:4;;5920:2;5938:18;;;6002:1;5998:14;;;5983:30;;5979:39;;6041:6;5742:4;6075:1201;6089:6;6086:1;6083:13;6075:1201;;;6154:22;;;-1:-1:-1;;6150:36:1;6138:49;;6226:20;;6301:14;6297:27;;;-1:-1:-1;;6293:42:1;6269:67;;6259:95;;6350:1;6347;6340:12;6259:95;6380:31;;6466:19;;6451:35;;6536:14;;;6523:28;6506:15;;;6499:53;6602:14;;;6589:28;6572:15;;;6565:53;6434:4;6641;6699:14;;;6686:28;6771:14;6767:26;;;-1:-1:-1;;6763:40:1;6737:67;;6727:95;;6818:1;6815;6808:12;6727:95;6850:32;;6909:21;;6957:18;6946:30;;6943:50;;;6989:1;6986;6979:12;6943:50;7040:6;7024:14;7020:27;7013:5;7009:39;7006:59;;;7061:1;7058;7051:12;7006:59;7102:2;7097;7089:6;7085:15;7078:27;7128:68;7192:2;7184:6;7180:15;7172:6;7167:2;7158:7;7154:16;7128:68;:::i;:::-;7254:12;;;;7118:78;-1:-1:-1;;;7219:15:1;;;;-1:-1:-1;;;6111:1:1;6104:9;6075:1201;;;-1:-1:-1;7293:6:1;;5522:1783;-1:-1:-1;;;;;;;;5522:1783:1:o;8995:407::-;9197:2;9179:21;;;9236:2;9216:18;;;9209:30;9275:34;9270:2;9255:18;;9248:62;-1:-1:-1;;;9341:2:1;9326:18;;9319:41;9392:3;9377:19;;8995:407::o;9752:244::-;9909:2;9898:9;9891:21;9872:4;9929:61;9986:2;9975:9;9971:18;9963:6;9955;9929:61;:::i;10001:258::-;10073:1;10083:113;10097:6;10094:1;10091:13;10083:113;;;10173:11;;;10167:18;10154:11;;;10147:39;10119:2;10112:10;10083:113;;;10214:6;10211:1;10208:13;10205:48;;;-1:-1:-1;;10249:1:1;10231:16;;10224:27;10001:258::o;10264:274::-;10393:3;10431:6;10425:13;10447:53;10493:6;10488:3;10481:4;10473:6;10469:17;10447:53;:::i;:::-;10516:16;;;;;10264:274;-1:-1:-1;;10264:274:1:o;10543:383::-;10692:2;10681:9;10674:21;10655:4;10724:6;10718:13;10767:6;10762:2;10751:9;10747:18;10740:34;10783:66;10842:6;10837:2;10826:9;10822:18;10817:2;10809:6;10805:15;10783:66;:::i;:::-;10910:2;10889:15;-1:-1:-1;;10885:29:1;10870:45;;;;10917:2;10866:54;;10543:383;-1:-1:-1;;10543:383:1:o;10931:184::-;11001:6;11054:2;11042:9;11033:7;11029:23;11025:32;11022:52;;;11070:1;11067;11060:12;11022:52;-1:-1:-1;11093:16:1;;10931:184;-1:-1:-1;10931:184:1:o;11120:127::-;11181:10;11176:3;11172:20;11169:1;11162:31;11212:4;11209:1;11202:15;11236:4;11233:1;11226:15;11252:125;11292:4;11320:1;11317;11314:8;11311:34;;;11325:18;;:::i;:::-;-1:-1:-1;11362:9:1;;11252:125::o;11382:128::-;11422:3;11453:1;11449:6;11446:1;11443:13;11440:39;;;11459:18;;:::i;:::-;-1:-1:-1;11495:9:1;;11382:128::o;11515:168::-;11555:7;11621:1;11617;11613:6;11609:14;11606:1;11603:21;11598:1;11591:9;11584:17;11580:45;11577:71;;;11628:18;;:::i;:::-;-1:-1:-1;11668:9:1;;11515:168::o;12635:127::-;12696:10;12691:3;12687:20;12684:1;12677:31;12727:4;12724:1;12717:15;12751:4;12748:1;12741:15;13117:773;13498:3;13536:6;13530:13;13552:53;13598:6;13593:3;13586:4;13578:6;13574:17;13552:53;:::i;:::-;-1:-1:-1;;;13627:16:1;;;13652:23;;;13700:13;;13722:65;13700:13;13774:1;13763:13;;13756:4;13744:17;;13722:65;:::i;:::-;-1:-1:-1;;;13850:1:1;13806:20;;;;13842:10;;;13835:23;13882:1;13874:10;;13117:773;-1:-1:-1;;;;13117:773:1:o;13895:::-;14276:3;14314:6;14308:13;14330:53;14376:6;14371:3;14364:4;14356:6;14352:17;14330:53;:::i;:::-;-1:-1:-1;;;14405:16:1;;;14430:23;;;14478:13;;14500:65;14478:13;14552:1;14541:13;;14534:4;14522:17;;14500:65;:::i;14673:447::-;14905:3;14943:6;14937:13;14959:53;15005:6;15000:3;14993:4;14985:6;14981:17;14959:53;:::i;:::-;-1:-1:-1;;;15034:16:1;;15059:26;;;-1:-1:-1;15112:1:1;15101:13;;14673:447;-1:-1:-1;14673:447:1:o;15505:277::-;15572:6;15625:2;15613:9;15604:7;15600:23;15596:32;15593:52;;;15641:1;15638;15631:12;15593:52;15673:9;15667:16;15726:5;15719:13;15712:21;15705:5;15702:32;15692:60;;15748:1;15745;15738:12;16385:127;16446:10;16441:3;16437:20;16434:1;16427:31;16477:4;16474:1;16467:15;16501:4;16498:1;16491:15;16517:135;16556:3;-1:-1:-1;;16577:17:1;;16574:43;;;16597:18;;:::i;:::-;-1:-1:-1;16644:1:1;16633:13;;16517:135::o

ipfs://45a21944aa79cc18d49b613c01923b2a70e46fac4b42f88048ffc688603bacdc