Contract 0xc3F10c9d09a15ABD438A45c38D2BED14FF2428c4

// SPDX-License-Identifier: MIT

/**
WinSwap Website : WwW.winSwap.WIN
*/
pragma solidity 0.8.10;

import "./IERC20.sol";
import "./SafeERC20.sol";
import "./GasStationRecipient.sol";
import "./ITokensApprover.sol";
import "./IHyperSwap.sol";
import "./LibBytesV06.sol";
import "./LibProxyRichErrors.sol";
import "./Ownable.sol";

contract HyperSwapRouter is GasStationRecipient, Ownable {
    using LibBytesV06 for bytes;
    using SafeERC20 for IERC20;

    // Native currency address (ETH - 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE, CELO - 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
    address private nativeAddress;

    address payable public beneficiary;
    address payable public allowanceTarget;
    IHyperSwap public hyperSwap;
    ITokensApprover public approver;

    uint256 public feeBeneficiary = 5; // 0.05%
    uint256[4] public feeReferrals = [4, 3, 2, 1];  // 0.05%, 0.03%, 0.02%, 0.01%

    event BeneficiaryChanged(address indexed beneficiary);
    event AllowanceTargetChanged(address indexed allowanceTarget);
    event HyperSwapChanged(address indexed hyperSwap);
    event TokensApproverChanged(address indexed approver);
    event FeePayment(address indexed recipient, address token, uint256 amount);

    /// @dev Construct this contract and specify a fee beneficiary, 0x proxy contract address, and allowance target
    constructor(address _nativeAddress, IHyperSwap _hyperSwap, address payable _allowanceTarget, address payable _beneficiary, address _gasStation, ITokensApprover _approver) {
        nativeAddress = _nativeAddress;
        hyperSwap = _hyperSwap;
        allowanceTarget = _allowanceTarget;
        beneficiary = _beneficiary;
        approver = _approver;

        _setGasStation(_gasStation);
    }

    /// @dev Fallback for just receiving ether.
    receive() external payable {}

    /// @dev Set a new MultiSwap proxy contract address
    /// @param _hyperSwap New Exchange proxy address
    function setHyperSwap(IHyperSwap _hyperSwap) public onlyOwner {
        require(address(_hyperSwap) != address(0), "Invalid HyperSwap address");
        hyperSwap = _hyperSwap;
        emit HyperSwapChanged(address(hyperSwap));
    }

    /// @dev Set a new new allowance target address
    /// @param _allowanceTarget New allowance target address
    function setAllowanceTarget(address payable _allowanceTarget) public onlyOwner {
        require(_allowanceTarget != address(0), "Invalid allowance target");
        allowanceTarget = _allowanceTarget;
        emit AllowanceTargetChanged(allowanceTarget);
    }

    /// @dev Set a new beneficiary address
    /// @param _beneficiary New beneficiary target address
    function setBeneficiary(address payable _beneficiary) public onlyOwner {
        require(_beneficiary != address(0), "Invalid beneficiary");
        beneficiary = _beneficiary;
        emit BeneficiaryChanged(beneficiary);
    }

    /// @dev Set a new trusted gas station address
    /// @param _gasStation New gas station address
    function setGasStation(address _gasStation) external onlyOwner {
        _setGasStation(_gasStation);
    }

    /// @dev Set a new tokens approver contract address
    /// @param _approver New approver address
    function setApprover(ITokensApprover _approver) external onlyOwner {
        require(address(_approver) != address(0), "Invalid beneficiary");
        approver = _approver;
        emit TokensApproverChanged(address(approver));
    }

    /// @dev Set a referrals fees
    /// @param _feeReferrals New referrals fees values
    function setFeeReferrals(uint256[4] memory _feeReferrals) public onlyOwner {
        feeReferrals = _feeReferrals;
    }

    /// @dev Set a beneficiary fees
    /// @param _feeBeneficiary New beneficiary fees value
    function setFeeBeneficiary(uint256 _feeBeneficiary) public onlyOwner {
        feeBeneficiary = _feeBeneficiary;
    }

    /// @dev Forwards calls to the HyperSwap contract and extracts a fee based on provided arguments
    /// @param msgData The byte data representing a swap using the original HyperSwap contract. This is either recieved from the Multiswap API directly or we construct it in order to perform a single swap trade
    /// @param inputToken The ERC20 the user is selling. If this is ETH it should be the standard 0xeee ETH address
    /// @param inputAmount The amount of inputToken being sold, without fees
    /// @param outputToken The ERC20 the user is buying. If this is ETH it should be the standard 0xeee ETH address
    /// @param referrals Referral addresses for which interest will be accrued from each exchange.
    function multiRoute(
        bytes calldata msgData,
        address inputToken,
        uint256 inputAmount,
        address outputToken,
        address[4] memory referrals
    ) external payable returns (bytes memory) {
    return _multiRoute(msgData, inputToken, inputAmount, outputToken, referrals);
    }

    function multiRouteWithPermit(
        bytes calldata msgData,
        address inputToken,
        uint256 inputAmount,
        address outputToken,
        address[4] memory referrals,
        bytes calldata approvalData
    ) external payable returns (bytes memory) {
        _permit(inputToken, approvalData);
        return _multiRoute(msgData, inputToken, inputAmount, outputToken, referrals);
    }

    function _multiRoute(
        bytes calldata msgData,
        address inputToken,
        uint256 inputAmount,
        address outputToken,
        address[4] memory referrals
    ) internal returns (bytes memory) {
        // Calculate total fees and send to beneficiary.
        uint256 inputAmountPercent = inputAmount / 10000;
        uint256 fee = inputAmountPercent * feeBeneficiary;
        _payFees(inputToken, fee, beneficiary);
        for (uint256 i = 0; i < referrals.length; i++) {
            if (referrals[i] != address(0) && feeReferrals[i] != 0) {
                uint256 feeReferral = inputAmountPercent * feeReferrals[i];
                fee = fee + feeReferral;
                _payFees(inputToken, feeReferral, payable(referrals[i]));
            }
        }

        // Checking the ETH balance and approve for token transfer
        uint256 value = 0;
        if (inputToken == nativeAddress) {
            require(msg.value == inputAmount + fee, "Insufficient value with fee");
            value = inputAmount;
        } else {
            _sendERC20(IERC20(inputToken), _msgSender(), address(this), inputAmount);
            uint256 allowedAmount = IERC20(inputToken).allowance(address(this), allowanceTarget);
            if (allowedAmount < inputAmount) {
                IERC20(inputToken).safeIncreaseAllowance(allowanceTarget, inputAmount - allowedAmount);
            }
        }

        // Call HyperSwap multi swap
        (bool success, bytes memory resultData) = address(hyperSwap).call{value : value}(msgData);

        if (!success) {
            _revertWithData(resultData);
        }

        // We send the received tokens back to the sender
        if (outputToken == nativeAddress) {
            if (address(this).balance > 0) {
                _sendETH(payable(_msgSender()), address(this).balance);
            } else {
                _revertWithData(resultData);
            }
        } else {
            uint256 tokenBalance = IERC20(outputToken).balanceOf(address(this));
            if (tokenBalance > 0) {
                IERC20(outputToken).safeTransfer(_msgSender(), tokenBalance);
            } else {
                _revertWithData(resultData);
            }
        }
        _returnWithData(resultData);
    }

    function _permit(address token, bytes calldata approvalData) internal {
        if (approvalData.length > 0 && approver.hasConfigured(token)) {
            (bool success,) = approver.callPermit(token, approvalData);
            require(success, "Permit Method Call Error");
        }
    }

    /// @dev Pay fee to beneficiary
    /// @param token token address to pay fee in, can be ETH
    /// @param amount fee amount to pay
    function _payFees(address token, uint256 amount, address payable recipient) private {
        if (token == nativeAddress) {
            _sendETH(recipient, amount);
        } else {
            _sendERC20(IERC20(token), _msgSender(), recipient, amount);
        }
        emit FeePayment(recipient, token, amount);
    }

    function _sendETH(address payable toAddress, uint256 amount) private {
        if (amount > 0) {
            (bool success,) = toAddress.call{value : amount}("");
            require(success, "Unable to send ETH");
        }
    }

    function _sendERC20(IERC20 token, address fromAddress, address toAddress, uint256 amount) private {
        if (amount > 0) {
            token.safeTransferFrom(fromAddress, toAddress, amount);
        }
    }

    /// @dev Revert with arbitrary bytes.
    /// @param data Revert data.
    function _revertWithData(bytes memory data) private pure {
        assembly {revert(add(data, 32), mload(data))}
    }

    /// @dev Return with arbitrary bytes.
    /// @param data Return data.
    function _returnWithData(bytes memory data) private pure {
        assembly {
            return (add(data, 32), mload(data))
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.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 functionCall(target, data, "Address: low-level call failed");
    }

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

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

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

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

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

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

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

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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

//SPDX-License-Identifier: MIT
pragma solidity 0.8.10;

/*
 * @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 GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSenderContext() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgDataContext() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;

import "./IGasStationRecipient.sol";

abstract contract GasStationRecipient is IGasStationRecipient {
    /*
     * Allowed Gas Station Contract for accept calls from
     */
    address private _gasStation;

    function isOwnGasStation(address addressToCheck) external view returns(bool) {
        return _gasStation == addressToCheck;
    }

    function gasStation() external view returns (address) {
        return _gasStation;
    }

    function _setGasStation(address newGasStation) internal {
        require(newGasStation != address(0), "Invalid new gas station address");
        _gasStation = newGasStation;
        emit GasStationChanged(_gasStation);
    }

    /**
    * return the sender of this call.
    * if the call came through our trusted forwarder, then the real sender is appended as the last 20 bytes
    * of the msg.data.
    * otherwise, return `msg.sender`
    * should be used in the contract anywhere instead of msg.sender
    */
    function _msgSender() internal view returns (address ret) {
        if (msg.data.length >= 20 && this.isOwnGasStation(msg.sender)) {
            // At this point we know that the sender is a trusted forwarder,
            // so we trust that the last bytes of msg.data are the verified sender address.
            // extract sender address from the end of msg.data
            assembly {
                ret := shr(96,calldataload(sub(calldatasize(),20)))
            }
        } else {
            ret = msg.sender;
        }
    }

    /**
     * return the msg.data of this call.
     * if the call came through our trusted forwarder, then the real sender was appended as the last 20 bytes
     * of the msg.data - so this method will strip those 20 bytes off.
     * otherwise (if the call was made directly and not through the forwarder), return `msg.data`
     * should be used in the contract instead of msg.data, where this difference matters.
     */
    function _msgData() internal view returns (bytes calldata ret) {
        if (msg.data.length >= 20 && this.isOwnGasStation(msg.sender)) {
            return msg.data[0:msg.data.length-20];
        } else {
            return msg.data;
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` tokens from the caller's account to `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);

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

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;

interface IGasStationRecipient {

    event GasStationChanged(address indexed gasStation);

    function isOwnGasStation(address addressToCheck) external view returns(bool);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;

interface IHyperSwap {
    function getFunctionImplementation(bytes4 _signature) external returns (address);
}

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;

interface ITokensApprover {
    /**
     * @notice Data for issuing permissions for the token
     */
    struct ApproveConfig {
        string name;
        string version;
        string domainType;
        string primaryType;
        string noncesMethod;
        string permitMethod;
        bytes4 permitMethodSelector;
    }

    event TokensApproverConfigAdded(uint256 indexed id);
    event TokensApproverConfigUpdated(uint256 indexed id);
    event TokensApproverTokenAdded(address indexed token, uint256 id);
    event TokensApproverTokenRemoved(address indexed token);

    function addConfig(ApproveConfig calldata config) external returns (uint256);

    function updateConfig(uint256 id, ApproveConfig calldata config) external returns (uint256);

    function setToken(uint256 id, address token) external;

    function removeToken(address token) external;

    function getConfig(address token) view external returns (ApproveConfig memory);

    function getConfigById(uint256 id) view external returns (ApproveConfig memory);

    function configsLength() view external returns (uint256);

    function hasConfigured(address token) view external returns (bool);

    function callPermit(address token, bytes calldata permitCallData) external returns (bool, bytes memory);
}

//SPDX-License-Identifier: MIT
pragma solidity 0.8.10;

library LibBytesRichErrorsV06 {

    enum InvalidByteOperationErrorCodes {
        FromLessThanOrEqualsToRequired,
        ToLessThanOrEqualsLengthRequired,
        LengthGreaterThanZeroRequired,
        LengthGreaterThanOrEqualsFourRequired,
        LengthGreaterThanOrEqualsTwentyRequired,
        LengthGreaterThanOrEqualsThirtyTwoRequired,
        LengthGreaterThanOrEqualsNestedBytesLengthRequired,
        DestinationLengthGreaterThanOrEqualSourceLengthRequired
    }

    // bytes4(keccak256("InvalidByteOperationError(uint8,uint256,uint256)"))
    bytes4 internal constant INVALID_BYTE_OPERATION_ERROR_SELECTOR =
    0x28006595;

    // solhint-disable func-name-mixedcase
    function InvalidByteOperationError(
        InvalidByteOperationErrorCodes errorCode,
        uint256 offset,
        uint256 required
    )
    internal
    pure
    returns (bytes memory)
    {
        return abi.encodeWithSelector(
            INVALID_BYTE_OPERATION_ERROR_SELECTOR,
            errorCode,
            offset,
            required
        );
    }
}

//SPDX-License-Identifier: MIT
pragma solidity 0.8.10;

import "./LibBytesRichErrorsV06.sol";
import "./LibRichErrorsV06.sol";

library LibBytesV06 {

    using LibBytesV06 for bytes;

    /// @dev Gets the memory address for a byte array.
    /// @param input Byte array to lookup.
    /// @return memoryAddress Memory address of byte array. This
    ///         points to the header of the byte array which contains
    ///         the length.
    function rawAddress(bytes memory input)
    internal
    pure
    returns (uint256 memoryAddress)
    {
        assembly {
            memoryAddress := input
        }
        return memoryAddress;
    }

    /// @dev Gets the memory address for the contents of a byte array.
    /// @param input Byte array to lookup.
    /// @return memoryAddress Memory address of the contents of the byte array.
    function contentAddress(bytes memory input)
    internal
    pure
    returns (uint256 memoryAddress)
    {
        assembly {
            memoryAddress := add(input, 32)
        }
        return memoryAddress;
    }

    /// @dev Copies `length` bytes from memory location `source` to `dest`.
    /// @param dest memory address to copy bytes to.
    /// @param source memory address to copy bytes from.
    /// @param length number of bytes to copy.
    function memCopy(
        uint256 dest,
        uint256 source,
        uint256 length
    )
    internal
    pure
    {
        if (length < 32) {
            // Handle a partial word by reading destination and masking
            // off the bits we are interested in.
            // This correctly handles overlap, zero lengths and source == dest
            assembly {
                let mask := sub(exp(256, sub(32, length)), 1)
                let s := and(mload(source), not(mask))
                let d := and(mload(dest), mask)
                mstore(dest, or(s, d))
            }
        } else {
            // Skip the O(length) loop when source == dest.
            if (source == dest) {
                return;
            }

            // For large copies we copy whole words at a time. The final
            // word is aligned to the end of the range (instead of after the
            // previous) to handle partial words. So a copy will look like this:
            //
            //  ####
            //      ####
            //          ####
            //            ####
            //
            // We handle overlap in the source and destination range by
            // changing the copying direction. This prevents us from
            // overwriting parts of source that we still need to copy.
            //
            // This correctly handles source == dest
            //
            if (source > dest) {
                assembly {
                // We subtract 32 from `sEnd` and `dEnd` because it
                // is easier to compare with in the loop, and these
                // are also the addresses we need for copying the
                // last bytes.
                    length := sub(length, 32)
                    let sEnd := add(source, length)
                    let dEnd := add(dest, length)

                // Remember the last 32 bytes of source
                // This needs to be done here and not after the loop
                // because we may have overwritten the last bytes in
                // source already due to overlap.
                    let last := mload(sEnd)

                // Copy whole words front to back
                // Note: the first check is always true,
                // this could have been a do-while loop.
                // solhint-disable-next-line no-empty-blocks
                    for {} lt(source, sEnd) {} {
                        mstore(dest, mload(source))
                        source := add(source, 32)
                        dest := add(dest, 32)
                    }

                // Write the last 32 bytes
                    mstore(dEnd, last)
                }
            } else {
                assembly {
                // We subtract 32 from `sEnd` and `dEnd` because those
                // are the starting points when copying a word at the end.
                    length := sub(length, 32)
                    let sEnd := add(source, length)
                    let dEnd := add(dest, length)

                // Remember the first 32 bytes of source
                // This needs to be done here and not after the loop
                // because we may have overwritten the first bytes in
                // source already due to overlap.
                    let first := mload(source)

                // Copy whole words back to front
                // We use a signed comparisson here to allow dEnd to become
                // negative (happens when source and dest < 32). Valid
                // addresses in local memory will never be larger than
                // 2**255, so they can be safely re-interpreted as signed.
                // Note: the first check is always true,
                // this could have been a do-while loop.
                // solhint-disable-next-line no-empty-blocks
                    for {} slt(dest, dEnd) {} {
                        mstore(dEnd, mload(sEnd))
                        sEnd := sub(sEnd, 32)
                        dEnd := sub(dEnd, 32)
                    }

                // Write the first 32 bytes
                    mstore(dest, first)
                }
            }
        }
    }

    /// @dev Returns a slices from a byte array.
    /// @param b The byte array to take a slice from.
    /// @param from The starting index for the slice (inclusive).
    /// @param to The final index for the slice (exclusive).
    /// @return result The slice containing bytes at indices [from, to)
    function slice(
        bytes memory b,
        uint256 from,
        uint256 to
    )
    internal
    pure
    returns (bytes memory result)
    {
        // Ensure that the from and to positions are valid positions for a slice within
        // the byte array that is being used.
        if (from > to) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
                    from,
                    to
                ));
        }
        if (to > b.length) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
                    to,
                    b.length
                ));
        }

        // Create a new bytes structure and copy contents
        result = new bytes(to - from);
        memCopy(
            result.contentAddress(),
            b.contentAddress() + from,
            result.length
        );
        return result;
    }

    /// @dev Returns a slice from a byte array without preserving the input.
    ///      When `from == 0`, the original array will match the slice.
    ///      In other cases its state will be corrupted.
    /// @param b The byte array to take a slice from. Will be destroyed in the process.
    /// @param from The starting index for the slice (inclusive).
    /// @param to The final index for the slice (exclusive).
    /// @return result The slice containing bytes at indices [from, to)
    function sliceDestructive(
        bytes memory b,
        uint256 from,
        uint256 to
    )
    internal
    pure
    returns (bytes memory result)
    {
        // Ensure that the from and to positions are valid positions for a slice within
        // the byte array that is being used.
        if (from > to) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
                    from,
                    to
                ));
        }
        if (to > b.length) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
                    to,
                    b.length
                ));
        }

        // Create a new bytes structure around [from, to) in-place.
        assembly {
            result := add(b, from)
            mstore(result, sub(to, from))
        }
        return result;
    }

    /// @dev Pops the last byte off of a byte array by modifying its length.
    /// @param b Byte array that will be modified.
    /// @return result The byte that was popped off.
    function popLastByte(bytes memory b)
    internal
    pure
    returns (bytes1 result)
    {
        if (b.length == 0) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanZeroRequired,
                    b.length,
                    0
                ));
        }

        // Store last byte.
        result = b[b.length - 1];

        assembly {
        // Decrement length of byte array.
            let newLen := sub(mload(b), 1)
            mstore(b, newLen)
        }
        return result;
    }

    /// @dev Tests equality of two byte arrays.
    /// @param lhs First byte array to compare.
    /// @param rhs Second byte array to compare.
    /// @return equal True if arrays are the same. False otherwise.
    function equals(
        bytes memory lhs,
        bytes memory rhs
    )
    internal
    pure
    returns (bool equal)
    {
        // Keccak gas cost is 30 + numWords * 6. This is a cheap way to compare.
        // We early exit on unequal lengths, but keccak would also correctly
        // handle this.
        return lhs.length == rhs.length && keccak256(lhs) == keccak256(rhs);
    }

    /// @dev Reads an address from a position in a byte array.
    /// @param b Byte array containing an address.
    /// @param index Index in byte array of address.
    /// @return result address from byte array.
    function readAddress(
        bytes memory b,
        uint256 index
    )
    internal
    pure
    returns (address result)
    {
        if (b.length < index + 20) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
                    b.length,
                    index + 20 // 20 is length of address
                ));
        }

        // Add offset to index:
        // 1. Arrays are prefixed by 32-byte length parameter (add 32 to index)
        // 2. Account for size difference between address length and 32-byte storage word (subtract 12 from index)
        index += 20;

        // Read address from array memory
        assembly {
        // 1. Add index to address of bytes array
        // 2. Load 32-byte word from memory
        // 3. Apply 20-byte mask to obtain address
            result := and(mload(add(b, index)), 0xffffffffffffffffffffffffffffffffffffffff)
        }
        return result;
    }

    /// @dev Writes an address into a specific position in a byte array.
    /// @param b Byte array to insert address into.
    /// @param index Index in byte array of address.
    /// @param input Address to put into byte array.
    function writeAddress(
        bytes memory b,
        uint256 index,
        address input
    )
    internal
    pure
    {
        if (b.length < index + 20) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
                    b.length,
                    index + 20 // 20 is length of address
                ));
        }

        // Add offset to index:
        // 1. Arrays are prefixed by 32-byte length parameter (add 32 to index)
        // 2. Account for size difference between address length and 32-byte storage word (subtract 12 from index)
        index += 20;

        // Store address into array memory
        assembly {
        // The address occupies 20 bytes and mstore stores 32 bytes.
        // First fetch the 32-byte word where we'll be storing the address, then
        // apply a mask so we have only the bytes in the word that the address will not occupy.
        // Then combine these bytes with the address and store the 32 bytes back to memory with mstore.

        // 1. Add index to address of bytes array
        // 2. Load 32-byte word from memory
        // 3. Apply 12-byte mask to obtain extra bytes occupying word of memory where we'll store the address
            let neighbors := and(
            mload(add(b, index)),
            0xffffffffffffffffffffffff0000000000000000000000000000000000000000
            )

        // Make sure input address is clean.
        // (Solidity does not guarantee this)
            input := and(input, 0xffffffffffffffffffffffffffffffffffffffff)

        // Store the neighbors and address into memory
            mstore(add(b, index), xor(input, neighbors))
        }
    }

    /// @dev Reads a bytes32 value from a position in a byte array.
    /// @param b Byte array containing a bytes32 value.
    /// @param index Index in byte array of bytes32 value.
    /// @return result bytes32 value from byte array.
    function readBytes32(
        bytes memory b,
        uint256 index
    )
    internal
    pure
    returns (bytes32 result)
    {
        if (b.length < index + 32) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
                    b.length,
                    index + 32
                ));
        }

        // Arrays are prefixed by a 256 bit length parameter
        index += 32;

        // Read the bytes32 from array memory
        assembly {
            result := mload(add(b, index))
        }
        return result;
    }

    /// @dev Writes a bytes32 into a specific position in a byte array.
    /// @param b Byte array to insert <input> into.
    /// @param index Index in byte array of <input>.
    /// @param input bytes32 to put into byte array.
    function writeBytes32(
        bytes memory b,
        uint256 index,
        bytes32 input
    )
    internal
    pure
    {
        if (b.length < index + 32) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
                    b.length,
                    index + 32
                ));
        }

        // Arrays are prefixed by a 256 bit length parameter
        index += 32;

        // Read the bytes32 from array memory
        assembly {
            mstore(add(b, index), input)
        }
    }

    /// @dev Reads a uint256 value from a position in a byte array.
    /// @param b Byte array containing a uint256 value.
    /// @param index Index in byte array of uint256 value.
    /// @return result uint256 value from byte array.
    function readUint256(
        bytes memory b,
        uint256 index
    )
    internal
    pure
    returns (uint256 result)
    {
        result = uint256(readBytes32(b, index));
        return result;
    }

    /// @dev Writes a uint256 into a specific position in a byte array.
    /// @param b Byte array to insert <input> into.
    /// @param index Index in byte array of <input>.
    /// @param input uint256 to put into byte array.
    function writeUint256(
        bytes memory b,
        uint256 index,
        uint256 input
    )
    internal
    pure
    {
        writeBytes32(b, index, bytes32(input));
    }

    /// @dev Reads an unpadded bytes4 value from a position in a byte array.
    /// @param b Byte array containing a bytes4 value.
    /// @param index Index in byte array of bytes4 value.
    /// @return result bytes4 value from byte array.
    function readBytes4(
        bytes memory b,
        uint256 index
    )
    internal
    pure
    returns (bytes4 result)
    {
        if (b.length < index + 4) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                    LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsFourRequired,
                    b.length,
                    index + 4
                ));
        }

        // Arrays are prefixed by a 32 byte length field
        index += 32;

        // Read the bytes4 from array memory
        assembly {
            result := mload(add(b, index))
        // Solidity does not require us to clean the trailing bytes.
        // We do it anyway
            result := and(result, 0xFFFFFFFF00000000000000000000000000000000000000000000000000000000)
        }
        return result;
    }

    /// @dev Writes a new length to a byte array.
    ///      Decreasing length will lead to removing the corresponding lower order bytes from the byte array.
    ///      Increasing length may lead to appending adjacent in-memory bytes to the end of the byte array.
    /// @param b Bytes array to write new length to.
    /// @param length New length of byte array.
    function writeLength(bytes memory b, uint256 length)
    internal
    pure
    {
        assembly {
            mstore(b, length)
        }
    }
}

//SPDX-License-Identifier: MIT
pragma solidity 0.8.10;

library LibProxyRichErrors {

    // solhint-disable func-name-mixedcase

    function NotImplementedError(bytes4 selector)
    internal
    pure
    returns (bytes memory)
    {
        return abi.encodeWithSelector(
            bytes4(keccak256("NotImplementedError(bytes4)")),
            selector
        );
    }

    function InvalidBootstrapCallerError(address actual, address expected)
    internal
    pure
    returns (bytes memory)
    {
        return abi.encodeWithSelector(
            bytes4(keccak256("InvalidBootstrapCallerError(address,address)")),
            actual,
            expected
        );
    }

    function InvalidDieCallerError(address actual, address expected)
    internal
    pure
    returns (bytes memory)
    {
        return abi.encodeWithSelector(
            bytes4(keccak256("InvalidDieCallerError(address,address)")),
            actual,
            expected
        );
    }

    function BootstrapCallFailedError(address target, bytes memory resultData)
    internal
    pure
    returns (bytes memory)
    {
        return abi.encodeWithSelector(
            bytes4(keccak256("BootstrapCallFailedError(address,bytes)")),
            target,
            resultData
        );
    }
}

//SPDX-License-Identifier: MIT
pragma solidity 0.8.10;

library LibRichErrorsV06 {

    // bytes4(keccak256("Error(string)"))
    bytes4 internal constant STANDARD_ERROR_SELECTOR = 0x08c379a0;

    // solhint-disable func-name-mixedcase
    /// @dev ABI encode a standard, string revert error payload.
    ///      This is the same payload that would be included by a `revert(string)`
    ///      solidity statement. It has the function signature `Error(string)`.
    /// @param message The error string.
    /// @return The ABI encoded error.
    function StandardError(string memory message)
    internal
    pure
    returns (bytes memory)
    {
        return abi.encodeWithSelector(
            STANDARD_ERROR_SELECTOR,
            bytes(message)
        );
    }
    // solhint-enable func-name-mixedcase

    /// @dev Reverts an encoded rich revert reason `errorData`.
    /// @param errorData ABI encoded error data.
    function rrevert(bytes memory errorData)
    internal
    pure
    {
        assembly {
            revert(add(errorData, 0x20), mload(errorData))
        }
    }
}

//SPDX-License-Identifier: MIT
pragma solidity 0.8.10;

import "./Context.sol";

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () {
        address msgSender = _msgSenderContext();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSenderContext(), "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 {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./Address.sol";

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

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

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

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

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

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

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

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

[{"inputs":[{"internalType":"address","name":"_nativeAddress","type":"address"},{"internalType":"contract IHyperSwap","name":"_hyperSwap","type":"address"},{"internalType":"address payable","name":"_allowanceTarget","type":"address"},{"internalType":"address payable","name":"_beneficiary","type":"address"},{"internalType":"address","name":"_gasStation","type":"address"},{"internalType":"contract ITokensApprover","name":"_approver","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"allowanceTarget","type":"address"}],"name":"AllowanceTargetChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"}],"name":"BeneficiaryChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FeePayment","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"gasStation","type":"address"}],"name":"GasStationChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"hyperSwap","type":"address"}],"name":"HyperSwapChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"approver","type":"address"}],"name":"TokensApproverChanged","type":"event"},{"inputs":[],"name":"allowanceTarget","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"approver","outputs":[{"internalType":"contract ITokensApprover","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"beneficiary","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeBeneficiary","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"feeReferrals","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gasStation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hyperSwap","outputs":[{"internalType":"contract IHyperSwap","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addressToCheck","type":"address"}],"name":"isOwnGasStation","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"msgData","type":"bytes"},{"internalType":"address","name":"inputToken","type":"address"},{"internalType":"uint256","name":"inputAmount","type":"uint256"},{"internalType":"address","name":"outputToken","type":"address"},{"internalType":"address[4]","name":"referrals","type":"address[4]"}],"name":"multiRoute","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"msgData","type":"bytes"},{"internalType":"address","name":"inputToken","type":"address"},{"internalType":"uint256","name":"inputAmount","type":"uint256"},{"internalType":"address","name":"outputToken","type":"address"},{"internalType":"address[4]","name":"referrals","type":"address[4]"},{"internalType":"bytes","name":"approvalData","type":"bytes"}],"name":"multiRouteWithPermit","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"_allowanceTarget","type":"address"}],"name":"setAllowanceTarget","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ITokensApprover","name":"_approver","type":"address"}],"name":"setApprover","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"_beneficiary","type":"address"}],"name":"setBeneficiary","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_feeBeneficiary","type":"uint256"}],"name":"setFeeBeneficiary","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[4]","name":"_feeReferrals","type":"uint256[4]"}],"name":"setFeeReferrals","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_gasStation","type":"address"}],"name":"setGasStation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IHyperSwap","name":"_hyperSwap","type":"address"}],"name":"setHyperSwap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee000000000000000000000000def1c0ded9bec7f1a1670819833240f027b25eff000000000000000000000000def1c0ded9bec7f1a1670819833240f027b25eff000000000000000000000000b9ac8b7513433aa3da00821cf6f9d37a09e0c398000000000000000000000000acd4fe965e53ceb419a0104a5b547ea5a797c20a000000000000000000000000b1bdd421c1bac7b065091a48eaf8f004a7bf3c6c

-----Decoded View---------------
Arg [0] : _nativeAddress (address): 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
Arg [1] : _hyperSwap (address): 0xdef1c0ded9bec7f1a1670819833240f027b25eff
Arg [2] : _allowanceTarget (address): 0xdef1c0ded9bec7f1a1670819833240f027b25eff
Arg [3] : _beneficiary (address): 0xb9ac8b7513433aa3da00821cf6f9d37a09e0c398
Arg [4] : _gasStation (address): 0xacd4fe965e53ceb419a0104a5b547ea5a797c20a
Arg [5] : _approver (address): 0xb1bdd421c1bac7b065091a48eaf8f004a7bf3c6c

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
Arg [1] : 000000000000000000000000def1c0ded9bec7f1a1670819833240f027b25eff
Arg [2] : 000000000000000000000000def1c0ded9bec7f1a1670819833240f027b25eff
Arg [3] : 000000000000000000000000b9ac8b7513433aa3da00821cf6f9d37a09e0c398
Arg [4] : 000000000000000000000000acd4fe965e53ceb419a0104a5b547ea5a797c20a
Arg [5] : 000000000000000000000000b1bdd421c1bac7b065091a48eaf8f004a7bf3c6c

347:9122:3:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3082:109;;;;;;;;;;-1:-1:-1;3082:109:3;;;;;:::i;:::-;;:::i;:::-;;3639:122;;;;;;;;;;-1:-1:-1;3639:122:3;;;;;:::i;:::-;;:::i;772:31::-;;;;;;;;;;-1:-1:-1;772:31:3;;;;-1:-1:-1;;;;;772:31:3;;;;;;-1:-1:-1;;;;;1652:55:14;;;1634:74;;1622:2;1607:18;772:31:3;;;;;;;;2738:232;;;;;;;;;;-1:-1:-1;2738:232:3;;;;;:::i;:::-;;:::i;3303:237::-;;;;;;;;;;-1:-1:-1;3303:237:3;;;;;:::i;:::-;;:::i;652:34::-;;;;;;;;;;-1:-1:-1;652:34:3;;;;-1:-1:-1;;;;;652:34:3;;;5045:414;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;812:33::-;;;;;;;;;;;;;;;;;;;5488:25:14;;;5476:2;5461:18;812:33:3;5342:177:14;738:27:3;;;;;;;;;;-1:-1:-1;738:27:3;;;;-1:-1:-1;;;;;738:27:3;;;1759:148:12;;;;;;;;;;;;;:::i;861:45:3:-;;;;;;;;;;-1:-1:-1;861:45:3;;;;;:::i;:::-;;:::i;2361:265::-;;;;;;;;;;-1:-1:-1;2361:265:3;;;;;:::i;:::-;;:::i;1101:87:12:-;;;;;;;;;;-1:-1:-1;1174:6:12;;-1:-1:-1;;;;;1174:6:12;1101:87;;693:38:3;;;;;;;;;;-1:-1:-1;693:38:3;;;;-1:-1:-1;;;;;693:38:3;;;315:132:2;;;;;;;;;;-1:-1:-1;315:132:2;;;;;:::i;:::-;386:4;410:11;-1:-1:-1;;;;;410:11:2;;;:29;;;;315:132;;;;6355:14:14;;6348:22;6330:41;;6318:2;6303:18;315:132:2;6190:187:14;3865:120:3;;;;;;;;;;-1:-1:-1;3865:120:3;;;;;:::i;:::-;;:::i;4719:318::-;;;;;;:::i;:::-;;:::i;2001:237::-;;;;;;;;;;-1:-1:-1;2001:237:3;;;;;:::i;:::-;;:::i;455:91:2:-;;;;;;;;;;-1:-1:-1;500:7:2;527:11;-1:-1:-1;;;;;527:11:2;455:91;;2062:244:12;;;;;;;;;;-1:-1:-1;2062:244:12;;;;;:::i;:::-;;:::i;3082:109:3:-;1174:6:12;;-1:-1:-1;;;;;1174:6:12;689:10:1;1321:30:12;1313:75;;;;-1:-1:-1;;;1313:75:12;;7727:2:14;1313:75:12;;;7709:21:14;;;7746:18;;;7739:30;7805:34;7785:18;;;7778:62;7857:18;;1313:75:12;;;;;;;;;3156:27:3::1;3171:11;3156:14;:27::i;:::-;3082:109:::0;:::o;3639:122::-;1174:6:12;;-1:-1:-1;;;;;1174:6:12;689:10:1;1321:30:12;1313:75;;;;-1:-1:-1;;;1313:75:12;;7727:2:14;1313:75:12;;;7709:21:14;;;7746:18;;;7739:30;7805:34;7785:18;;;7778:62;7857:18;;1313:75:12;7525:356:14;1313:75:12;3725:28:3::1;:12;3740:13:::0;3725:28:::1;;:::i;:::-;;3639:122:::0;:::o;2738:232::-;1174:6:12;;-1:-1:-1;;;;;1174:6:12;689:10:1;1321:30:12;1313:75;;;;-1:-1:-1;;;1313:75:12;;7727:2:14;1313:75:12;;;7709:21:14;;;7746:18;;;7739:30;7805:34;7785:18;;;7778:62;7857:18;;1313:75:12;7525:356:14;1313:75:12;-1:-1:-1;;;;;2828:26:3;::::1;2820:58;;;::::0;-1:-1:-1;;;2820:58:3;;8088:2:14;2820:58:3::1;::::0;::::1;8070:21:14::0;8127:2;8107:18;;;8100:30;8166:21;8146:18;;;8139:49;8205:18;;2820:58:3::1;7886:343:14::0;2820:58:3::1;2889:11;:26:::0;;-1:-1:-1;;;;;;2889:26:3::1;-1:-1:-1::0;;;;;2889:26:3;::::1;::::0;;::::1;::::0;;;2931:31:::1;::::0;::::1;::::0;-1:-1:-1;;2931:31:3::1;2738:232:::0;:::o;3303:237::-;1174:6:12;;-1:-1:-1;;;;;1174:6:12;689:10:1;1321:30:12;1313:75;;;;-1:-1:-1;;;1313:75:12;;7727:2:14;1313:75:12;;;7709:21:14;;;7746:18;;;7739:30;7805:34;7785:18;;;7778:62;7857:18;;1313:75:12;7525:356:14;1313:75:12;-1:-1:-1;;;;;3389:32:3;::::1;3381:64;;;::::0;-1:-1:-1;;;3381:64:3;;8088:2:14;3381:64:3::1;::::0;::::1;8070:21:14::0;8127:2;8107:18;;;8100:30;8166:21;8146:18;;;8139:49;8205:18;;3381:64:3::1;7886:343:14::0;3381:64:3::1;3456:8;:20:::0;;-1:-1:-1;;;;;;3456:20:3::1;-1:-1:-1::0;;;;;3456:20:3;::::1;::::0;;::::1;::::0;;;3492:40:::1;::::0;::::1;::::0;-1:-1:-1;;3492:40:3::1;3303:237:::0;:::o;5045:414::-;5306:12;5331:33;5339:10;5351:12;;5331:7;:33::i;:::-;5382:69;5394:7;;5403:10;5415:11;5428;5441:9;5382:11;:69::i;:::-;5375:76;5045:414;-1:-1:-1;;;;;;;;;5045:414:3:o;1759:148:12:-;1174:6;;-1:-1:-1;;;;;1174:6:12;689:10:1;1321:30:12;1313:75;;;;-1:-1:-1;;;1313:75:12;;7727:2:14;1313:75:12;;;7709:21:14;;;7746:18;;;7739:30;7805:34;7785:18;;;7778:62;7857:18;;1313:75:12;7525:356:14;1313:75:12;1850:6:::1;::::0;1829:40:::1;::::0;1866:1:::1;::::0;-1:-1:-1;;;;;1850:6:12::1;::::0;1829:40:::1;::::0;1866:1;;1829:40:::1;1880:6;:19:::0;;-1:-1:-1;;;;;;1880:19:12::1;::::0;;1759:148::o;861:45:3:-;;;;;;;;;;;;;;;-1:-1:-1;861:45:3;:::o;2361:265::-;1174:6:12;;-1:-1:-1;;;;;1174:6:12;689:10:1;1321:30:12;1313:75;;;;-1:-1:-1;;;1313:75:12;;7727:2:14;1313:75:12;;;7709:21:14;;;7746:18;;;7739:30;7805:34;7785:18;;;7778:62;7857:18;;1313:75:12;7525:356:14;1313:75:12;-1:-1:-1;;;;;2459:30:3;::::1;2451:67;;;::::0;-1:-1:-1;;;2451:67:3;;8436:2:14;2451:67:3::1;::::0;::::1;8418:21:14::0;8475:2;8455:18;;;8448:30;8514:26;8494:18;;;8487:54;8558:18;;2451:67:3::1;8234:348:14::0;2451:67:3::1;2529:15;:34:::0;;-1:-1:-1;;;;;;2529:34:3::1;-1:-1:-1::0;;;;;2529:34:3;::::1;::::0;;::::1;::::0;;;2579:39:::1;::::0;::::1;::::0;-1:-1:-1;;2579:39:3::1;2361:265:::0;:::o;3865:120::-;1174:6:12;;-1:-1:-1;;;;;1174:6:12;689:10:1;1321:30:12;1313:75;;;;-1:-1:-1;;;1313:75:12;;7727:2:14;1313:75:12;;;7709:21:14;;;7746:18;;;7739:30;7805:34;7785:18;;;7778:62;7857:18;;1313:75:12;7525:356:14;1313:75:12;3945:14:3::1;:32:::0;3865:120::o;4719:318::-;4932:12;4960:69;4972:7;;4981:10;4993:11;5006;5019:9;4960:11;:69::i;:::-;4953:76;4719:318;-1:-1:-1;;;;;;;4719:318:3:o;2001:237::-;1174:6:12;;-1:-1:-1;;;;;1174:6:12;689:10:1;1321:30:12;1313:75;;;;-1:-1:-1;;;1313:75:12;;7727:2:14;1313:75:12;;;7709:21:14;;;7746:18;;;7739:30;7805:34;7785:18;;;7778:62;7857:18;;1313:75:12;7525:356:14;1313:75:12;-1:-1:-1;;;;;2082:33:3;::::1;2074:71;;;::::0;-1:-1:-1;;;2074:71:3;;8789:2:14;2074:71:3::1;::::0;::::1;8771:21:14::0;8828:2;8808:18;;;8801:30;8867:27;8847:18;;;8840:55;8912:18;;2074:71:3::1;8587:349:14::0;2074:71:3::1;2156:9;:22:::0;;-1:-1:-1;;;;;;2156:22:3::1;-1:-1:-1::0;;;;;2156:22:3;::::1;::::0;;::::1;::::0;;;2194:36:::1;::::0;::::1;::::0;-1:-1:-1;;2194:36:3::1;2001:237:::0;:::o;2062:244:12:-;1174:6;;-1:-1:-1;;;;;1174:6:12;689:10:1;1321:30:12;1313:75;;;;-1:-1:-1;;;1313:75:12;;7727:2:14;1313:75:12;;;7709:21:14;;;7746:18;;;7739:30;7805:34;7785:18;;;7778:62;7857:18;;1313:75:12;7525:356:14;1313:75:12;-1:-1:-1;;;;;2151:22:12;::::1;2143:73;;;::::0;-1:-1:-1;;;2143:73:12;;9143:2:14;2143:73:12::1;::::0;::::1;9125:21:14::0;9182:2;9162:18;;;9155:30;9221:34;9201:18;;;9194:62;9292:8;9272:18;;;9265:36;9318:19;;2143:73:12::1;8941:402:14::0;2143:73:12::1;2253:6;::::0;2232:38:::1;::::0;-1:-1:-1;;;;;2232:38:12;;::::1;::::0;2253:6:::1;::::0;2232:38:::1;::::0;2253:6:::1;::::0;2232:38:::1;2281:6;:17:::0;;-1:-1:-1;;;;;;2281:17:12::1;-1:-1:-1::0;;;;;2281:17:12;;;::::1;::::0;;;::::1;::::0;;2062:244::o;554:230:2:-;-1:-1:-1;;;;;629:27:2;;621:71;;;;-1:-1:-1;;;621:71:2;;9550:2:14;621:71:2;;;9532:21:14;9589:2;9569:18;;;9562:30;9628:33;9608:18;;;9601:61;9679:18;;621:71:2;9348:355:14;621:71:2;703:11;:27;;-1:-1:-1;;;;;;703:27:2;-1:-1:-1;;;;;703:27:2;;;;;;;746:30;;703:27;;746:30;;;554:230;:::o;7798:294:3:-;7883:23;;;;;:56;;-1:-1:-1;7910:8:3;;:29;;;;;-1:-1:-1;;;;;1652:55:14;;;7910:29:3;;;1634:74:14;7910:8:3;;;;:22;;1607:18:14;;7910:29:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;7879:206;;;7974:8;;:40;;;;;7957:12;;-1:-1:-1;;;;;7974:8:3;;:19;;:40;;7994:5;;8001:12;;;;7974:40;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;7974:40:3;;;;;;;;;;;;:::i;:::-;7956:58;;;8037:7;8029:44;;;;-1:-1:-1;;;8029:44:3;;11766:2:14;8029:44:3;;;11748:21:14;11805:2;11785:18;;;11778:30;11844:26;11824:18;;;11817:54;11888:18;;8029:44:3;11564:348:14;8029:44:3;7941:144;7879:206;7798:294;;;:::o;5467:2323::-;5673:12;5756:26;5785:19;5799:5;5785:11;:19;:::i;:::-;5756:48;;5815:11;5850:14;;5829:18;:35;;;;:::i;:::-;5901:11;;5815:49;;-1:-1:-1;5875:38:3;;5884:10;;5815:49;;-1:-1:-1;;;;;5901:11:3;5875:8;:38::i;:::-;5929:9;5924:339;5948:16;5944:1;:20;5924:339;;;6014:1;5990:9;6000:1;5990:12;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;5990:26:3;;;:50;;;;;6020:12;6033:1;6020:15;;;;;;;:::i;:::-;;;:20;;5990:50;5986:266;;;6061:19;6104:12;6117:1;6104:15;;;;;;;:::i;:::-;;;6083:36;;:18;:36;:::i;:::-;6061:58;-1:-1:-1;6144:17:3;6061:58;6144:3;:17;:::i;:::-;6138:23;;6180:56;6189:10;6201:11;6222:9;6232:1;6222:12;;;;;;;:::i;:::-;;;;;6180:8;:56::i;:::-;6042:210;5986:266;5966:3;;;;:::i;:::-;;;;5924:339;;;-1:-1:-1;6389:13:3;;6343;;-1:-1:-1;;;;;6375:27:3;;;6389:13;;6375:27;6371:536;;;6440:17;6454:3;6440:11;:17;:::i;:::-;6427:9;:30;6419:70;;;;-1:-1:-1;;;6419:70:3;;13222:2:14;6419:70:3;;;13204:21:14;13261:2;13241:18;;;13234:30;13300:29;13280:18;;;13273:57;13347:18;;6419:70:3;13020:351:14;6419:70:3;-1:-1:-1;6512:11:3;6371:536;;;6556:72;6574:10;6587:12;:10;:12::i;:::-;6609:4;6616:11;6556:10;:72::i;:::-;6711:15;;;6667:60;;-1:-1:-1;;;6667:60:3;;6704:4;6667:60;;;13619:34:14;;;;-1:-1:-1;;;;;6711:15:3;;;13669:18:14;;;13662:43;6643:21:3;;6667:28;;;;;;13531:18:14;;6667:60:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6643:84;;6762:11;6746:13;:27;6742:154;;;6835:15;;6794:86;;-1:-1:-1;;;;;6835:15:3;6852:27;6866:13;6852:11;:27;:::i;:::-;-1:-1:-1;;;;;6794:40:3;;;:86;:40;:86::i;:::-;6541:366;6371:536;7007:9;;6999:47;;6958:12;;;;-1:-1:-1;;;;;7007:9:3;;;;7031:5;;6999:47;;7038:7;;;;6999:47;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6957:89;;;;7064:7;7059:68;;7088:27;7104:10;7088:15;:27::i;:::-;7217:13;;-1:-1:-1;;;;;7202:28:3;;;7217:13;;7202:28;7198:547;;;7251:21;:25;7247:188;;7297:54;7314:12;:10;:12::i;:::-;7329:21;7297:8;:54::i;:::-;7198:547;;7247:188;7392:27;7408:10;7392:15;:27::i;7198:547::-;7490:44;;;;;7528:4;7490:44;;;1634:74:14;7467:20:3;;-1:-1:-1;;;;;7490:29:3;;;;;1607:18:14;;7490:44:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;7467:67;-1:-1:-1;7553:16:3;;7549:185;;7590:60;7623:12;:10;:12::i;:::-;-1:-1:-1;;;;;7590:32:3;;;7637:12;7590:32;:60::i;:::-;7549:185;;;7691:27;7707:10;7691:15;:27::i;:::-;7452:293;7198:547;7755:27;7771:10;7755:15;:27::i;:::-;5687:2103;;;;;5467:2323;;;;;;;;:::o;8240:327::-;8348:13;;-1:-1:-1;;;;;8339:22:3;;;8348:13;;8339:22;8335:173;;;8378:27;8387:9;8398:6;8378:8;:27::i;:::-;8335:173;;;8438:58;8456:5;8464:12;:10;:12::i;:::-;8478:9;8489:6;8438:10;:58::i;:::-;8523:36;;;-1:-1:-1;;;;;14503:55:14;;;14485:74;;14590:2;14575:18;;14568:34;;;8523:36:3;;;;;14458:18:14;8523:36:3;;;;;;;8240:327;;;:::o;1088:543:2:-;1133:11;1180:2;1161:8;:21;;;;:57;;-1:-1:-1;1186:32:2;;;;;1207:10;1186:32;;;1634:74:14;1186:4:2;;:20;;1607:18:14;;1186:32:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1157:467;;;-1:-1:-1;;;1529:14:2;1525:22;1512:36;1509:2;1505:44;1088:543;:::o;1157:467::-;-1:-1:-1;1602:10:2;1088:543;:::o;8818:213:3:-;8931:10;;8927:97;;8958:54;-1:-1:-1;;;;;8958:22:3;;8981:11;8994:9;9005:6;8958:22;:54::i;2067:317:13:-;2221:39;;-1:-1:-1;;;2221:39:13;;2245:4;2221:39;;;13619:34:14;-1:-1:-1;;;;;13689:15:14;;;13669:18;;;13662:43;2198:20:13;;2263:5;;2221:15;;;;;13531:18:14;;2221:39:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:47;;;;:::i;:::-;2306:69;;-1:-1:-1;;;;;14503:55:14;;2306:69:13;;;14485:74:14;14575:18;;;14568:34;;;2198:70:13;;-1:-1:-1;2279:97:13;;2299:5;;2329:22;;14458:18:14;;2306:69:13;;;;-1:-1:-1;;2306:69:13;;;;;;;;;;;;;;;;;;;;;;;;;;;2279:19;:97::i;9116:120:3:-;9222:4;9216:11;9211:2;9205:4;9201:13;9194:34;8575:235;8659:10;;8655:148;;8687:12;8704:9;-1:-1:-1;;;;;8704:14:3;8727:6;8704:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8686:52;;;8761:7;8753:38;;;;-1:-1:-1;;;8753:38:3;;15357:2:14;8753:38:3;;;15339:21:14;15396:2;15376:18;;;15369:30;15435:20;15415:18;;;15408:48;15473:18;;8753:38:3;15155:342:14;707:211:13;851:58;;-1:-1:-1;;;;;14503:55:14;;851:58:13;;;14485:74:14;14575:18;;;14568:34;;;824:86:13;;844:5;;874:23;;14458:18:14;;851:58:13;14311:297:14;9321:145:3;9442:4;9436:11;9431:2;9425:4;9421:13;9413:35;926:248:13;1097:68;;-1:-1:-1;;;;;15783:15:14;;;1097:68:13;;;15765:34:14;15835:15;;15815:18;;;15808:43;15867:18;;;15860:34;;;1070:96:13;;1090:5;;1120:27;;15677:18:14;;1097:68:13;15502:398:14;3280:716:13;3704:23;3730:69;3758:4;3730:69;;;;;;;;;;;;;;;;;3738:5;-1:-1:-1;;;;;3730:27:13;;;:69;;;;;:::i;:::-;3814:17;;3704:95;;-1:-1:-1;3814:21:13;3810:179;;3911:10;3900:30;;;;;;;;;;;;:::i;:::-;3892:85;;;;-1:-1:-1;;;3892:85:13;;16107:2:14;3892:85:13;;;16089:21:14;16146:2;16126:18;;;16119:30;16185:34;16165:18;;;16158:62;16256:12;16236:18;;;16229:40;16286:19;;3892:85:13;15905:406:14;3955:229:0;4092:12;4124:52;4146:6;4154:4;4160:1;4163:12;4124:21;:52::i;:::-;4117:59;;3955:229;;;;;;:::o;5075:510::-;5245:12;5303:5;5278:21;:30;;5270:81;;;;-1:-1:-1;;;5270:81:0;;16518:2:14;5270:81:0;;;16500:21:14;16557:2;16537:18;;;16530:30;16596:34;16576:18;;;16569:62;16667:8;16647:18;;;16640:36;16693:19;;5270:81:0;16316:402:14;5270:81:0;-1:-1:-1;;;;;1505:19:0;;;5362:60;;;;-1:-1:-1;;;5362:60:0;;16925:2:14;5362:60:0;;;16907:21:14;16964:2;16944:18;;;16937:30;17003:31;16983:18;;;16976:59;17052:18;;5362:60:0;16723:353:14;5362:60:0;5436:12;5450:23;5477:6;-1:-1:-1;;;;;5477:11:0;5496:5;5503:4;5477:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5435:73;;;;5526:51;5543:7;5552:10;5564:12;7911;7940:7;7936:530;;;-1:-1:-1;7971:10:0;7964:17;;7936:530;8085:17;;:21;8081:374;;8283:10;8277:17;8344:15;8331:10;8327:2;8323:19;8316:44;8081:374;8426:12;8419:20;;-1:-1:-1;;;8419:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:154:14;-1:-1:-1;;;;;93:5:14;89:54;82:5;79:65;69:93;;158:1;155;148:12;173:247;232:6;285:2;273:9;264:7;260:23;256:32;253:52;;;301:1;298;291:12;253:52;340:9;327:23;359:31;384:5;359:31;:::i;425:184::-;-1:-1:-1;;;474:1:14;467:88;574:4;571:1;564:15;598:4;595:1;588:15;614:247;681:2;675:9;723:3;711:16;;757:18;742:34;;778:22;;;739:62;736:88;;;804:18;;:::i;:::-;840:2;833:22;614:247;:::o;866:593::-;948:6;1001:3;989:9;980:7;976:23;972:33;969:53;;;1018:1;1015;1008:12;969:53;1067:7;1060:4;1049:9;1045:20;1041:34;1031:62;;1089:1;1086;1079:12;1031:62;1113:17;;:::i;:::-;1152:3;1193;1182:9;1178:19;1220:7;1212:6;1209:19;1206:39;;;1241:1;1238;1231:12;1206:39;1265:9;1283:146;1299:6;1294:3;1291:15;1283:146;;;1367:17;;1355:30;;1414:4;1405:14;;;;1316;1283:146;;;-1:-1:-1;1448:5:14;;866:593;-1:-1:-1;;;;;866:593:14:o;2502:347::-;2553:8;2563:6;2617:3;2610:4;2602:6;2598:17;2594:27;2584:55;;2635:1;2632;2625:12;2584:55;-1:-1:-1;2658:20:14;;2701:18;2690:30;;2687:50;;;2733:1;2730;2723:12;2687:50;2770:4;2762:6;2758:17;2746:29;;2822:3;2815:4;2806:6;2798;2794:19;2790:30;2787:39;2784:59;;;2839:1;2836;2829:12;2784:59;2502:347;;;;;:::o;2854:555::-;2904:5;2957:3;2950:4;2942:6;2938:17;2934:27;2924:55;;2975:1;2972;2965:12;2924:55;2999:17;;:::i;:::-;3038:3;3076;3068:6;3064:16;3103:3;3095:6;3092:15;3089:35;;;3120:1;3117;3110:12;3089:35;3144:6;3159:221;3175:6;3170:3;3167:15;3159:221;;;3257:3;3244:17;3274:31;3299:5;3274:31;:::i;:::-;3318:18;;3365:4;3356:14;;;;3192;3159:221;;3414:1176;3563:6;3571;3579;3587;3595;3603;3611;3619;3672:3;3660:9;3651:7;3647:23;3643:33;3640:53;;;3689:1;3686;3679:12;3640:53;3729:9;3716:23;3758:18;3799:2;3791:6;3788:14;3785:34;;;3815:1;3812;3805:12;3785:34;3854:58;3904:7;3895:6;3884:9;3880:22;3854:58;:::i;:::-;3931:8;;-1:-1:-1;3828:84:14;-1:-1:-1;4016:2:14;4001:18;;3988:32;;-1:-1:-1;4029:31:14;3988:32;4029:31;:::i;:::-;4079:5;;-1:-1:-1;4131:2:14;4116:18;;4103:32;;-1:-1:-1;4187:2:14;4172:18;;4159:32;;4200:33;4159:32;4200:33;:::i;:::-;4252:7;4242:17;;4278:54;4324:7;4318:3;4307:9;4303:19;4278:54;:::i;:::-;4268:64;;4385:3;4374:9;4370:19;4357:33;4341:49;;4415:2;4405:8;4402:16;4399:36;;;4431:1;4428;4421:12;4399:36;;4470:60;4522:7;4511:8;4500:9;4496:24;4470:60;:::i;:::-;3414:1176;;;;-1:-1:-1;3414:1176:14;;-1:-1:-1;3414:1176:14;;;;;;4549:8;-1:-1:-1;;;3414:1176:14:o;4595:258::-;4667:1;4677:113;4691:6;4688:1;4685:13;4677:113;;;4767:11;;;4761:18;4748:11;;;4741:39;4713:2;4706:10;4677:113;;;4808:6;4805:1;4802:13;4799:48;;;-1:-1:-1;;4843:1:14;4825:16;;4818:27;4595:258::o;4858:257::-;4899:3;4937:5;4931:12;4964:6;4959:3;4952:19;4980:63;5036:6;5029:4;5024:3;5020:14;5013:4;5006:5;5002:16;4980:63;:::i;:::-;5097:2;5076:15;-1:-1:-1;;5072:29:14;5063:39;;;;5104:4;5059:50;;4858:257;-1:-1:-1;;4858:257:14:o;5120:217::-;5267:2;5256:9;5249:21;5230:4;5287:44;5327:2;5316:9;5312:18;5304:6;5287:44;:::i;5774:180::-;5833:6;5886:2;5874:9;5865:7;5861:23;5857:32;5854:52;;;5902:1;5899;5892:12;5854:52;-1:-1:-1;5925:23:14;;5774:180;-1:-1:-1;5774:180:14:o;6382:867::-;6511:6;6519;6527;6535;6543;6551;6604:3;6592:9;6583:7;6579:23;6575:33;6572:53;;;6621:1;6618;6611:12;6572:53;6661:9;6648:23;6694:18;6686:6;6683:30;6680:50;;;6726:1;6723;6716:12;6680:50;6765:58;6815:7;6806:6;6795:9;6791:22;6765:58;:::i;:::-;6842:8;;-1:-1:-1;6739:84:14;-1:-1:-1;;6927:2:14;6912:18;;6899:32;6940:31;6899:32;6940:31;:::i;:::-;6990:5;-1:-1:-1;7042:2:14;7027:18;;7014:32;;-1:-1:-1;7098:2:14;7083:18;;7070:32;7111:33;7070:32;7111:33;:::i;:::-;7163:7;-1:-1:-1;7189:54:14;7235:7;7229:3;7214:19;;7189:54;:::i;:::-;7179:64;;6382:867;;;;;;;;:::o;9708:164::-;9784:13;;9833;;9826:21;9816:32;;9806:60;;9862:1;9859;9852:12;9806:60;9708:164;;;:::o;9877:202::-;9944:6;9997:2;9985:9;9976:7;9972:23;9968:32;9965:52;;;10013:1;10010;10003:12;9965:52;10036:37;10063:9;10036:37;:::i;10084:508::-;-1:-1:-1;;;;;10273:6:14;10269:55;10258:9;10251:74;10361:2;10356;10345:9;10341:18;10334:30;10400:6;10395:2;10384:9;10380:18;10373:34;10457:6;10449;10444:2;10433:9;10429:18;10416:48;10513:1;10484:22;;;10508:2;10480:31;;;10473:42;;;;10576:2;10555:15;;;-1:-1:-1;;10551:29:14;10536:45;10532:54;;10084:508;-1:-1:-1;;10084:508:14:o;10597:962::-;10682:6;10690;10743:2;10731:9;10722:7;10718:23;10714:32;10711:52;;;10759:1;10756;10749:12;10711:52;10782:37;10809:9;10782:37;:::i;:::-;10772:47;;10863:2;10852:9;10848:18;10842:25;10886:18;10927:2;10919:6;10916:14;10913:34;;;10943:1;10940;10933:12;10913:34;10981:6;10970:9;10966:22;10956:32;;11026:7;11019:4;11015:2;11011:13;11007:27;10997:55;;11048:1;11045;11038:12;10997:55;11077:2;11071:9;11099:2;11095;11092:10;11089:36;;;11105:18;;:::i;:::-;11180:2;11174:9;11148:2;11234:13;;-1:-1:-1;;11230:22:14;;;11254:2;11226:31;11222:40;11210:53;;;11278:18;;;11298:22;;;11275:46;11272:72;;;11324:18;;:::i;:::-;11364:10;11360:2;11353:22;11399:2;11391:6;11384:18;11439:7;11434:2;11429;11425;11421:11;11417:20;11414:33;11411:53;;;11460:1;11457;11450:12;11411:53;11473:55;11525:2;11520;11512:6;11508:15;11503:2;11499;11495:11;11473:55;:::i;:::-;11547:6;11537:16;;;;;;;10597:962;;;;;:::o;11917:184::-;-1:-1:-1;;;11966:1:14;11959:88;12066:4;12063:1;12056:15;12090:4;12087:1;12080:15;12106:274;12146:1;12172;12162:189;;-1:-1:-1;;;12204:1:14;12197:88;12308:4;12305:1;12298:15;12336:4;12333:1;12326:15;12162:189;-1:-1:-1;12365:9:14;;12106:274::o;12385:168::-;12425:7;12491:1;12487;12483:6;12479:14;12476:1;12473:21;12468:1;12461:9;12454:17;12450:45;12447:71;;;12498:18;;:::i;:::-;-1:-1:-1;12538:9:14;;12385:168::o;12558:184::-;-1:-1:-1;;;12607:1:14;12600:88;12707:4;12704:1;12697:15;12731:4;12728:1;12721:15;12747:128;12787:3;12818:1;12814:6;12811:1;12808:13;12805:39;;;12824:18;;:::i;:::-;-1:-1:-1;12860:9:14;;12747:128::o;12880:135::-;12919:3;-1:-1:-1;;12940:17:14;;12937:43;;;12960:18;;:::i;:::-;-1:-1:-1;13007:1:14;12996:13;;12880:135::o;13716:184::-;13786:6;13839:2;13827:9;13818:7;13814:23;13810:32;13807:52;;;13855:1;13852;13845:12;13807:52;-1:-1:-1;13878:16:14;;13716:184;-1:-1:-1;13716:184:14:o;13905:125::-;13945:4;13973:1;13970;13967:8;13964:34;;;13978:18;;:::i;:::-;-1:-1:-1;14015:9:14;;13905:125::o;14035:271::-;14218:6;14210;14205:3;14192:33;14174:3;14244:16;;14269:13;;;14244:16;14035:271;-1:-1:-1;14035:271:14:o;17081:274::-;17210:3;17248:6;17242:13;17264:53;17310:6;17305:3;17298:4;17290:6;17286:17;17264:53;:::i;:::-;17333:16;;;;;17081:274;-1:-1:-1;;17081:274:14:o

ipfs://b71a35018b3e22d2d6848c89fe30da3e7ef2e7f8585b6f90bdd110cbd1d9824a