Contract 0x228ffd7122d202c0cd24330892881c47b0817c7a

/**
 *Submitted for verification at FtmScan.com on 2021-08-17
*/

// Sources flattened with hardhat v2.5.0 https://hardhat.org

// File @openzeppelin/contracts/token/ERC20/[email protected]

// SPDX-License-Identifier: MIT

pragma solidity 0.8.4;

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

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

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

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

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

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

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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


// File contracts/interfaces/IHandler.sol

interface IHandler {
    /// @notice receive ETH
    receive() external payable;

    /**
     * @notice Handle an order execution
     * @param _inToken - Address of the input token
     * @param _outToken - Address of the output token
     * @param _amountIn - uint256 of the input token amount
     * @param _amountOutMin - uint256 of the min return amount of output token
     * @param _data - Bytes of arbitrary data
     * @return bought - Amount of output token bought
     */
    function handle(
        IERC20 _inToken,
        IERC20 _outToken,
        uint256 _amountIn,
        uint256 _amountOutMin,
        bytes calldata _data
    ) external payable returns (uint256 bought);

    /**
     * @notice Check whether can handle an order execution
     * @param _inToken - Address of the input token
     * @param _outToken - Address of the output token
     * @param _amountIn - uint256 of the input token amount
     * @param _amountOutMin - uint256 of the min return amount of output token
     * @param _data - Bytes of arbitrary data
     * @return bool - Whether the execution can be handled or not
     */
    function canHandle(
        IERC20 _inToken,
        IERC20 _outToken,
        uint256 _amountIn,
        uint256 _amountOutMin,
        bytes calldata _data
    ) external view returns (bool);
}


// File contracts/interfaces/uniswap/IUniswapV2Router02.sol

interface IUniswapV2Router02 {
    function swapExactETHForTokens(
        uint256 minAmountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 minAmountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 minAmountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapTokensForExactETH(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function getAmountsOut(uint256 amountIn, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);

    function getAmountsIn(uint256 amountOut, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);

    function factory() external pure returns (address);

    // solhint-disable-next-line func-name-mixedcase
    function WETH() external pure returns (address);
}


// File @openzeppelin/contracts/utils/[email protected]



/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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


// File @openzeppelin/contracts/token/ERC20/utils/[email protected]




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

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

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

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

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

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

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

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


// File contracts/constants/Tokens.sol


address constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;


// File contracts/lib/TokenUtils.sol




library TokenUtils {
    using Address for address payable;
    using SafeERC20 for IERC20;

    function transfer(
        address _token,
        address _to,
        uint256 _amt
    ) internal {
        if (_token == ETH) payable(_to).sendValue(_amt);
        else IERC20(_token).safeTransfer(_to, _amt);
    }

    function balanceOf(address _token, address _account)
        internal
        view
        returns (uint256)
    {
        return
            ETH == _token
                ? _account.balance
                : IERC20(_token).balanceOf(_account);
    }
}


// File contracts/interfaces/IWETH.sol



interface IWETH is IERC20 {
    function deposit() external payable;

    function withdraw(uint256 wad) external;
}


// File contracts/lib/GelatoString.sol

library GelatoString {
    function revertWithInfo(string memory _error, string memory _tracingInfo)
        internal
        pure
    {
        revert(string(abi.encodePacked(_tracingInfo, _error)));
    }

    function prefix(string memory _second, string memory _first)
        internal
        pure
        returns (string memory)
    {
        return string(abi.encodePacked(_first, _second));
    }

    function suffix(string memory _first, string memory _second)
        internal
        pure
        returns (string memory)
    {
        return string(abi.encodePacked(_first, _second));
    }
}


// File contracts/functions/uniswap/FUniswapV2.sol






function _swapExactXForX(
    address WETH, // solhint-disable-line var-name-mixedcase
    IUniswapV2Router02 _uniRouter,
    uint256 _amountIn,
    uint256 _amountOutMin,
    address[] memory _path,
    address _to,
    uint256 _deadline
) returns (uint256) {
    if (_path[0] == ETH) {
        _path[0] = WETH;
        return
            _swapExactETHForTokens(
                _uniRouter,
                _amountIn,
                _amountOutMin,
                _path,
                _to,
                _deadline
            );
    }

    SafeERC20.safeIncreaseAllowance(
        IERC20(_path[0]),
        address(_uniRouter),
        _amountIn
    );

    if (_path[_path.length - 1] == ETH) {
        _path[_path.length - 1] = WETH;
        return
            _swapExactTokensForETH(
                _uniRouter,
                _amountIn,
                _amountOutMin,
                _path,
                _to,
                _deadline
            );
    }

    return
        _swapExactTokensForTokens(
            _uniRouter,
            _amountIn,
            _amountOutMin,
            _path,
            _to,
            _deadline
        );
}

function _swapExactETHForTokens(
    IUniswapV2Router02 _uniRouter,
    uint256 _amountIn,
    uint256 _amountOutMin,
    address[] memory _path, // must be ETH-WETH SANITIZED!
    address _to,
    uint256 _deadline
) returns (uint256 amountOut) {
    try
        _uniRouter.swapExactETHForTokens{value: _amountIn}(
            _amountOutMin,
            _path,
            _to,
            _deadline
        )
    returns (uint256[] memory amounts) {
        amountOut = amounts[amounts.length - 1];
    } catch Error(string memory error) {
        GelatoString.revertWithInfo(error, "_swapExactETHForTokens:");
    } catch {
        revert("_swapExactETHForTokens:undefined");
    }
}

function _swapExactTokensForETH(
    IUniswapV2Router02 _uniRouter,
    uint256 _amountIn,
    uint256 _amountOutMin,
    address[] memory _path, // must be ETH-WETH SANITIZED!
    address _to,
    uint256 _deadline
) returns (uint256 amountOut) {
    try
        _uniRouter.swapExactTokensForETH(
            _amountIn,
            _amountOutMin,
            _path,
            _to,
            _deadline
        )
    returns (uint256[] memory amounts) {
        amountOut = amounts[amounts.length - 1];
    } catch Error(string memory error) {
        GelatoString.revertWithInfo(error, "_swapExactTokensForETH:");
    } catch {
        revert("_swapExactTokensForETH:undefined");
    }
}

function _swapExactTokensForTokens(
    IUniswapV2Router02 _uniRouter,
    uint256 _amountIn,
    uint256 _amountOutMin,
    address[] memory _path, // must be ETH-WETH SANITIZED!
    address _to,
    uint256 _deadline
) returns (uint256 amountOut) {
    try
        _uniRouter.swapExactTokensForTokens(
            _amountIn,
            _amountOutMin,
            _path,
            _to,
            _deadline
        )
    returns (uint256[] memory amounts) {
        amountOut = amounts[amounts.length - 1];
    } catch Error(string memory error) {
        GelatoString.revertWithInfo(error, "_swapExactTokensForTokens:");
    } catch {
        revert("_swapExactTokensForTokens:undefined");
    }
}

function _swapTokensForExactETH(
    IUniswapV2Router02 _uniRouter,
    uint256 _amountOut,
    uint256 _amountInMax,
    address[] memory _path, // must be ETH-WETH SANITIZED!
    address _to,
    uint256 _deadline
) returns (uint256 amountIn) {
    SafeERC20.safeIncreaseAllowance(
        IERC20(_path[0]),
        address(_uniRouter),
        _amountInMax
    );

    try
        _uniRouter.swapTokensForExactETH(
            _amountOut,
            _amountInMax,
            _path,
            _to,
            _deadline
        )
    returns (uint256[] memory amounts) {
        return amounts[0];
    } catch Error(string memory error) {
        GelatoString.revertWithInfo(error, "_swapTokensForExactETH:");
    } catch {
        revert("_swapTokensForExactETH:undefined");
    }
}


// File contracts/handlers/uniswap/UniswapV2Router02Handler.sol

/// @notice UniswapV2 Handler used to execute an order via UniswapV2Router02
/// @dev This does NOT implement the standard IHANDLER
contract UniswapV2Router02Handler is IHandler {
    using TokenUtils for address;

    // solhint-disable var-name-mixedcase
    IUniswapV2Router02 public UNI_ROUTER;
    address public immutable WETH;

    // solhint-enable var-name-mixedcase

    constructor(IUniswapV2Router02 _uniRouter, address _weth) {
        UNI_ROUTER = _uniRouter;
        WETH = _weth;
    }

    /// @notice receive ETH from UniV2Router02 during swapXForEth
    receive() external payable override {
        require(
            msg.sender != tx.origin,
            "UniswapV2Router02Handler#receive: NO_SEND_ETH_PLEASE"
        );
    }

    /**
     * @notice Handle an order execution
     * @param _inToken - Address of the input token
     * @param _outToken - Address of the output token
     * @param _amountOutMin - Address of the output token
     * @param _data - (module, relayer, fee, intermediatePath, intermediateFeePath)
     * @return bought - Amount of output token bought
     */
    // solhint-disable-next-line function-max-lines
    function handle(
        IERC20 _inToken,
        IERC20 _outToken,
        uint256,
        uint256 _amountOutMin,
        bytes calldata _data
    ) external payable override returns (uint256 bought) {
        (
            address inToken,
            address outToken,
            uint256 amountIn,
            address[] memory path,
            address relayer,
            uint256 fee,
            address[] memory feePath
        ) = _handleInputData(_inToken, _outToken, _data);

        // Swap and charge fee in ETH
        if (inToken == WETH || inToken == ETH) {
            if (inToken == WETH) IWETH(WETH).withdraw(fee);
            bought = _swap(amountIn - fee, _amountOutMin, path, msg.sender);
        } else if (outToken == WETH || outToken == ETH) {
            bought = _swap(amountIn, _amountOutMin + fee, path, address(this));
            if (outToken == WETH) IWETH(WETH).withdraw(fee);
            outToken.transfer(msg.sender, bought - fee);
        } else {
            uint256 feeAmountIn = _swapTokensForExactETH(
                UNI_ROUTER,
                fee, // amountOut (in ETH)
                amountIn, // amountInMax (in inputToken)
                feePath,
                address(this),
                block.timestamp + 1 // solhint-disable-line not-rely-on-time
            );
            _swap(amountIn - feeAmountIn, _amountOutMin, path, msg.sender);
        }

        // Send fee to relayer
        (bool successRelayer, ) = relayer.call{value: fee}("");
        require(
            successRelayer,
            "UniswapV2Router02Handler#handle: TRANSFER_ETH_TO_RELAYER_FAILED"
        );
    }

    /**
     * @notice Check whether can handle an order execution
     * @param _inToken - Address of the input token
     * @param _outToken - Address of the output token
     * @param _amountIn - uint256 of the input token amount
     * @param _minReturn - uint256 of the min return amount of output token
     * @param _data - (module, relayer, fee, intermediatePath)
     * @return bool - Whether the execution can be handled or not
     */
    // solhint-disable-next-line code-complexity
    function canHandle(
        IERC20 _inToken,
        IERC20 _outToken,
        uint256 _amountIn,
        uint256 _minReturn,
        bytes calldata _data
    ) external view override returns (bool) {
        (
            address inToken,
            address outToken,
            ,
            address[] memory path,
            ,
            uint256 fee,
            address[] memory feePath
        ) = _handleInputData(_inToken, _outToken, _data);

        if (inToken == WETH || inToken == ETH) {
            if (_amountIn <= fee) return false;
            return _getAmountOut(_amountIn - fee, path) >= _minReturn;
        } else if (outToken == WETH || outToken == ETH) {
            uint256 bought = _getAmountOut(_amountIn, path);
            if (bought <= fee) return false;
            return bought - fee >= _minReturn;
        } else {
            uint256 inTokenFee = _getAmountIn(fee, feePath);
            if (inTokenFee >= _amountIn) return false;
            return _getAmountOut(_amountIn - inTokenFee, path) >= _minReturn;
        }
    }

    function _swap(
        uint256 _amountIn,
        uint256 _amountOutMin,
        address[] memory _path,
        address _recipient
    ) private returns (uint256 bought) {
        bought = _swapExactXForX(
            WETH,
            UNI_ROUTER,
            _amountIn,
            _amountOutMin,
            _path,
            _recipient,
            block.timestamp + 1 // solhint-disable-line not-rely-on-time
        );
    }

    function _getAmountOut(uint256 _amountIn, address[] memory _path)
        private
        view
        returns (uint256 amountOut)
    {
        uint256[] memory amountsOut = UNI_ROUTER.getAmountsOut(
            _amountIn,
            _path
        );
        amountOut = amountsOut[amountsOut.length - 1];
    }

    function _getAmountIn(uint256 _amountOut, address[] memory _path)
        private
        view
        returns (uint256 amountIn)
    {
        uint256[] memory amountsIn = UNI_ROUTER.getAmountsIn(_amountOut, _path);
        amountIn = amountsIn[0];
    }

    function _handleInputData(
        IERC20 _inToken,
        IERC20 _outToken,
        bytes calldata _data
    )
        private
        view
        returns (
            address inToken,
            address outToken,
            uint256 amountIn,
            address[] memory path,
            address relayer,
            uint256 fee,
            address[] memory feePath
        )
    {
        inToken = address(_inToken);
        outToken = address(_outToken);

        // Load real initial balance, don't trust provided value
        amountIn = inToken.balanceOf(address(this));

        // Decode extra data;
        (, relayer, fee, path, feePath) = abi.decode(
            _data,
            (address, address, uint256, address[], address[])
        );
    }
}


// File contracts/handlers/spiritswap/SpiritSwapHandler.sol



contract SpiritSwapHandler is UniswapV2Router02Handler {
    constructor(IUniswapV2Router02 _spiritRouter, address _weth)
        UniswapV2Router02Handler(_spiritRouter, _weth)
    {} // solhint-disable-line no-empty-blocks
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IUniswapV2Router02","name":"_spiritRouter","type":"address"},{"internalType":"address","name":"_weth","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"UNI_ROUTER","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_inToken","type":"address"},{"internalType":"contract IERC20","name":"_outToken","type":"address"},{"internalType":"uint256","name":"_amountIn","type":"uint256"},{"internalType":"uint256","name":"_minReturn","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"canHandle","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_inToken","type":"address"},{"internalType":"contract IERC20","name":"_outToken","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"_amountOutMin","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"handle","outputs":[{"internalType":"uint256","name":"bought","type":"uint256"}],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

60a06040523480156200001157600080fd5b5060405162001cb838038062001cb883398101604081905262000034916200006b565b600080546001600160a01b0319166001600160a01b03939093169290921790915560601b6001600160601b031916608052620000c2565b600080604083850312156200007e578182fd5b82516200008b81620000a9565b60208401519092506200009e81620000a9565b809150509250929050565b6001600160a01b0381168114620000bf57600080fd5b50565b60805160601c611b986200012060003960008181610108015281816101a60152818161023e01528181610345015281816103a6015281816103f401528181610477015281816104ef0152818161053d015261089d0152611b986000f3fe6080604052600436106100435760003560e01c806334ef68dd146100c1578063ad5c4648146100f6578063e42f5ea514610142578063ee0ab4651461016357600080fd5b366100bc57333214156100ba5760405162461bcd60e51b815260206004820152603460248201527f556e69737761705632526f75746572303248616e646c657223726563656976656044820152733a204e4f5f53454e445f4554485f504c4541534560601b60648201526084015b60405180910390fd5b005b600080fd5b3480156100cd57600080fd5b506100e16100dc3660046117c8565b610183565b60405190151581526020015b60405180910390f35b34801561010257600080fd5b5061012a7f000000000000000000000000000000000000000000000000000000000000000081565b6040516001600160a01b0390911681526020016100ed565b6101556101503660046117c8565b61031d565b6040519081526020016100ed565b34801561016f57600080fd5b5060005461012a906001600160a01b031681565b6000806000806000806101988c8c8a8a6106e0565b9650965050955050945094507f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316856001600160a01b0316148061020057506001600160a01b03851673eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee145b1561023c57818a1161021a57600095505050505050610313565b8861022e610228848d611a0c565b85610722565b101595505050505050610313565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316846001600160a01b0316148061029857506001600160a01b03841673eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee145b156102db5760006102a98b85610722565b90508281116102c15760009650505050505050610313565b896102cc8483611a0c565b10159650505050505050610313565b60006102e783836107e9565b90508a81106102ff5760009650505050505050610313565b896102cc61030d838e611a0c565b86610722565b9695505050505050565b6000806000806000806000806103358e8e8c8c6106e0565b96509650965096509650965096507f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316876001600160a01b0316148061039f57506001600160a01b03871673eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee145b15610475577f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316876001600160a01b0316141561045957604051632e1a7d4d60e01b8152600481018390527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031690632e1a7d4d90602401600060405180830381600087803b15801561044057600080fd5b505af1158015610454573d6000803e3d6000fd5b505050505b61046e6104668387611a0c565b8c8633610893565b9750610605565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316866001600160a01b031614806104d157506001600160a01b03861673eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee145b156105c6576104eb856104e4848e6119f4565b8630610893565b97507f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316866001600160a01b031614156105a257604051632e1a7d4d60e01b8152600481018390527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031690632e1a7d4d90602401600060405180830381600087803b15801561058957600080fd5b505af115801561059d573d6000803e3d6000fd5b505050505b6105c1336105b0848b611a0c565b6001600160a01b03891691906108e3565b610605565b600080546105eb906001600160a01b0316848885306105e64260016119f4565b610934565b90506106026105fa8288611a0c565b8d8733610893565b50505b6000836001600160a01b03168360405160006040518083038185875af1925050503d8060008114610652576040519150601f19603f3d011682016040523d82523d6000602084013e610657565b606091505b50509050806106ce5760405162461bcd60e51b815260206004820152603f60248201527f556e69737761705632526f75746572303248616e646c65722368616e646c653a60448201527f205452414e534645525f4554485f544f5f52454c415945525f4641494c45440060648201526084016100b1565b50505050505050509695505050505050565b8383600060608180826106fc6001600160a01b03881630610ad8565b945061070a888a018a61167b565b9a9f999e50979c50969a509850949695945050505050565b6000805460405163d06ca61f60e01b815282916001600160a01b03169063d06ca61f906107559087908790600401611946565b60006040518083038186803b15801561076d57600080fd5b505afa158015610781573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526107a9919081019061170b565b905080600182516107ba9190611a0c565b815181106107d857634e487b7160e01b600052603260045260246000fd5b602002602001015191505092915050565b600080546040516307c0329d60e21b815282916001600160a01b031690631f00ca749061081c9087908790600401611946565b60006040518083038186803b15801561083457600080fd5b505afa158015610848573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052610870919081019061170b565b9050806000815181106107d857634e487b7160e01b600052603260045260246000fd5b600080546108da907f0000000000000000000000000000000000000000000000000000000000000000906001600160a01b0316878787876108d54260016119f4565b610b8f565b95945050505050565b6001600160a01b03831673eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee14156109205761091b6001600160a01b03831682610d4b565b505050565b61091b6001600160a01b0384168383610e64565b60006109698460008151811061095a57634e487b7160e01b600052603260045260246000fd5b60200260200101518887610ec7565b604051632512eca560e11b81526001600160a01b03881690634a25d94a9061099d9089908990899089908990600401611994565b600060405180830381600087803b1580156109b757600080fd5b505af19250505080156109ec57506040513d6000823e601f3d908101601f191682016040526109e9919081019061170b565b60015b610aa7576109f8611aa8565b806308c379a01415610a5d5750610a0d611ac0565b80610a185750610a5f565b610a57816040518060400160405280601781526020017f5f73776170546f6b656e73466f7245786163744554483a000000000000000000815250610f8e565b50610313565b505b60405162461bcd60e51b815260206004820181905260248201527f5f73776170546f6b656e73466f7245786163744554483a756e646566696e656460448201526064016100b1565b80600081518110610ac857634e487b7160e01b600052603260045260246000fd5b6020026020010151915050610313565b600073eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee6001600160a01b03841614610b7c576040516370a0823160e01b81526001600160a01b0383811660048301528416906370a082319060240160206040518083038186803b158015610b3f57600080fd5b505afa158015610b53573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b77919061186d565b610b88565b816001600160a01b0316315b9392505050565b600073eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee6001600160a01b031684600081518110610bd057634e487b7160e01b600052603260045260246000fd5b60200260200101516001600160a01b03161415610c3e578784600081518110610c0957634e487b7160e01b600052603260045260246000fd5b60200260200101906001600160a01b031690816001600160a01b031681525050610c37878787878787610fc7565b9050610d40565b610c7184600081518110610c6257634e487b7160e01b600052603260045260246000fd5b60200260200101518888610ec7565b73eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee6001600160a01b03168460018651610c9e9190611a0c565b81518110610cbc57634e487b7160e01b600052603260045260246000fd5b60200260200101516001600160a01b03161415610d2f57878460018651610ce39190611a0c565b81518110610d0157634e487b7160e01b600052603260045260246000fd5b60200260200101906001600160a01b031690816001600160a01b031681525050610c37878787878787611142565b610d3d87878787878761127d565b90505b979650505050505050565b80471015610d9b5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a20696e73756666696369656e742062616c616e636500000060448201526064016100b1565b6000826001600160a01b03168260405160006040518083038185875af1925050503d8060008114610de8576040519150601f19603f3d011682016040523d82523d6000602084013e610ded565b606091505b505090508061091b5760405162461bcd60e51b815260206004820152603a60248201527f416464726573733a20756e61626c6520746f2073656e642076616c75652c207260448201527f6563697069656e74206d6179206861766520726576657274656400000000000060648201526084016100b1565b6040516001600160a01b03831660248201526044810182905261091b90849063a9059cbb60e01b906064015b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b0319909316929092179091526113c4565b604051636eb1769f60e11b81523060048201526001600160a01b038381166024830152600091839186169063dd62ed3e9060440160206040518083038186803b158015610f1357600080fd5b505afa158015610f27573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610f4b919061186d565b610f5591906119f4565b6040516001600160a01b038516602482015260448101829052909150610f8890859063095ea7b360e01b90606401610e90565b50505050565b8082604051602001610fa19291906118e4565b60408051601f198184030181529082905262461bcd60e51b82526100b191600401611913565b6000866001600160a01b0316637ff36ab587878787876040518663ffffffff1660e01b8152600401610ffc949392919061195f565b6000604051808303818588803b15801561101557600080fd5b505af19350505050801561104b57506040513d6000823e601f3d908101601f19168201604052611048919081019061170b565b60015b61110057611057611aa8565b806308c379a014156110b6575061106c611ac0565b8061107757506110b8565b610a57816040518060400160405280601781526020017f5f737761704578616374455448466f72546f6b656e733a000000000000000000815250610f8e565b505b60405162461bcd60e51b815260206004820181905260248201527f5f737761704578616374455448466f72546f6b656e733a756e646566696e656460448201526064016100b1565b806001825161110f9190611a0c565b8151811061112d57634e487b7160e01b600052603260045260246000fd5b60200260200101519150509695505050505050565b6040516318cbafe560e01b81526000906001600160a01b038816906318cbafe5906111799089908990899089908990600401611994565b600060405180830381600087803b15801561119357600080fd5b505af19250505080156111c857506040513d6000823e601f3d908101601f191682016040526111c5919081019061170b565b60015b611100576111d4611aa8565b806308c379a0141561123357506111e9611ac0565b806111f45750611235565b610a57816040518060400160405280601781526020017f5f737761704578616374546f6b656e73466f724554483a000000000000000000815250610f8e565b505b60405162461bcd60e51b815260206004820181905260248201527f5f737761704578616374546f6b656e73466f724554483a756e646566696e656460448201526064016100b1565b6040516338ed173960e01b81526000906001600160a01b038816906338ed1739906112b49089908990899089908990600401611994565b600060405180830381600087803b1580156112ce57600080fd5b505af192505050801561130357506040513d6000823e601f3d908101601f19168201604052611300919081019061170b565b60015b6111005761130f611aa8565b806308c379a0141561136e5750611324611ac0565b8061132f5750611370565b610a57816040518060400160405280601a81526020017f5f737761704578616374546f6b656e73466f72546f6b656e733a000000000000815250610f8e565b505b60405162461bcd60e51b815260206004820152602360248201527f5f737761704578616374546f6b656e73466f72546f6b656e733a756e646566696044820152621b995960ea1b60648201526084016100b1565b6000611419826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166114969092919063ffffffff16565b80519091501561091b578080602001905181019061143791906117a8565b61091b5760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b60648201526084016100b1565b60606114a584846000856114ad565b949350505050565b60608247101561150e5760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6044820152651c8818d85b1b60d21b60648201526084016100b1565b843b61155c5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016100b1565b600080866001600160a01b0316858760405161157891906118c8565b60006040518083038185875af1925050503d80600081146115b5576040519150601f19603f3d011682016040523d82523d6000602084013e6115ba565b606091505b5091509150610d40828286606083156115d4575081610b88565b8251156115e45782518084602001fd5b8160405162461bcd60e51b81526004016100b19190611913565b600082601f83011261160e578081fd5b8135602061161b826119d0565b6040516116288282611a4f565b8381528281019150858301600585901b87018401881015611647578586fd5b855b8581101561166e57813561165c81611b4a565b84529284019290840190600101611649565b5090979650505050505050565b600080600080600060a08688031215611692578081fd5b853561169d81611b4a565b945060208601356116ad81611b4a565b935060408601359250606086013567ffffffffffffffff808211156116d0578283fd5b6116dc89838a016115fe565b935060808801359150808211156116f1578283fd5b506116fe888289016115fe565b9150509295509295909350565b6000602080838503121561171d578182fd5b825167ffffffffffffffff811115611733578283fd5b8301601f81018513611743578283fd5b805161174e816119d0565b60405161175b8282611a4f565b8281528481019150838501600584901b8501860189101561177a578687fd5b8694505b8385101561179c57805183526001949094019391850191850161177e565b50979650505050505050565b6000602082840312156117b9578081fd5b81518015158114610b88578182fd5b60008060008060008060a087890312156117e0578081fd5b86356117eb81611b4a565b955060208701356117fb81611b4a565b94506040870135935060608701359250608087013567ffffffffffffffff80821115611825578283fd5b818901915089601f830112611838578283fd5b813581811115611846578384fd5b8a6020828501011115611857578384fd5b6020830194508093505050509295509295509295565b60006020828403121561187e578081fd5b5051919050565b6000815180845260208085019450808401835b838110156118bd5781516001600160a01b031687529582019590820190600101611898565b509495945050505050565b600082516118da818460208701611a23565b9190910192915050565b600083516118f6818460208801611a23565b83519083019061190a818360208801611a23565b01949350505050565b6020815260008251806020840152611932816040850160208701611a23565b601f01601f19169190910160400192915050565b8281526040602082015260006114a56040830184611885565b8481526080602082015260006119786080830186611885565b6001600160a01b03949094166040830152506060015292915050565b85815284602082015260a0604082015260006119b360a0830186611885565b6001600160a01b0394909416606083015250608001529392505050565b600067ffffffffffffffff8211156119ea576119ea611a92565b5060051b60200190565b60008219821115611a0757611a07611a7c565b500190565b600082821015611a1e57611a1e611a7c565b500390565b60005b83811015611a3e578181015183820152602001611a26565b83811115610f885750506000910152565b601f8201601f1916810167ffffffffffffffff81118282101715611a7557611a75611a92565b6040525050565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052604160045260246000fd5b600060033d1115611abd57600481823e5160e01c5b90565b600060443d1015611ace5790565b6040516003193d81016004833e81513d67ffffffffffffffff8160248401118184111715611afe57505050505090565b8285019150815181811115611b165750505050505090565b843d8701016020828501011115611b305750505050505090565b611b3f60208286010187611a4f565b509095945050505050565b6001600160a01b0381168114611b5f57600080fd5b5056fea2646970667358221220fcef35cfec520c2921eb7e00e4e4c2bf22a5727cd1288198d094a725c850164c64736f6c63430008040033000000000000000000000000f491e7b69e4244ad4002bc14e878a34207e38c2900000000000000000000000021be370d5312f44cb42ce377bc9b8a0cef1a4c83

000000000000000000000000f491e7b69e4244ad4002bc14e878a34207e38c2900000000000000000000000021be370d5312f44cb42ce377bc9b8a0cef1a4c83

-----Decoded View---------------
Arg [0] : _spiritRouter (address): 0xf491e7b69e4244ad4002bc14e878a34207e38c29
Arg [1] : _weth (address): 0x21be370d5312f44cb42ce377bc9b8a0cef1a4c83

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000f491e7b69e4244ad4002bc14e878a34207e38c29
Arg [1] : 00000000000000000000000021be370d5312f44cb42ce377bc9b8a0cef1a4c83

29947:229:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24188:10;24202:9;24188:23;;24166:125;;;;-1:-1:-1;;;24166:125:0;;8080:2:1;24166:125:0;;;8062:21:1;8119:2;8099:18;;;8092:30;8158:34;8138:18;;;8131:62;-1:-1:-1;;;8209:18:1;;;8202:50;8269:19;;24166:125:0;;;;;;;;;29947:229;;;;;26923:1088;;;;;;;;;;-1:-1:-1;26923:1088:0;;;;;:::i;:::-;;:::i;:::-;;;6825:14:1;;6818:22;6800:41;;6788:2;6773:18;26923:1088:0;;;;;;;;23839:29;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;6028:32:1;;;6010:51;;5998:2;5983:18;23839:29:0;5965:102:1;24727:1683:0;;;;;;:::i;:::-;;:::i;:::-;;;11921:25:1;;;11909:2;11894:18;24727:1683:0;11876:76:1;23796:36:0;;;;;;;;;;-1:-1:-1;23796:36:0;;;;-1:-1:-1;;;;;23796:36:0;;;26923:1088;27122:4;27154:15;27184:16;27230:21;27281:11;27307:24;27345:44;27362:8;27372:9;27383:5;;27345:16;:44::i;:::-;27139:250;;;;;;;;;;;;27417:4;-1:-1:-1;;;;;27406:15:0;:7;-1:-1:-1;;;;;27406:15:0;;:33;;;-1:-1:-1;;;;;;27425:14:0;;17656:42;27425:14;27406:33;27402:602;;;27473:3;27460:9;:16;27456:34;;27485:5;27478:12;;;;;;;;;27456:34;27552:10;27512:36;27526:15;27538:3;27526:9;:15;:::i;:::-;27543:4;27512:13;:36::i;:::-;:50;;27505:57;;;;;;;;;27402:602;27596:4;-1:-1:-1;;;;;27584:16:0;:8;-1:-1:-1;;;;;27584:16:0;;:35;;;-1:-1:-1;;;;;;27604:15:0;;17656:42;27604:15;27584:35;27580:424;;;27636:14;27653:30;27667:9;27678:4;27653:13;:30::i;:::-;27636:47;;27712:3;27702:6;:13;27698:31;;27724:5;27717:12;;;;;;;;;;27698:31;27767:10;27751:12;27760:3;27751:6;:12;:::i;:::-;:26;;27744:33;;;;;;;;;;27580:424;27810:18;27831:26;27844:3;27849:7;27831:12;:26::i;:::-;27810:47;;27890:9;27876:10;:23;27872:41;;27908:5;27901:12;;;;;;;;;;27872:41;27982:10;27935:43;27949:22;27961:10;27949:9;:22;:::i;:::-;27973:4;27935:13;:43::i;26923:1088::-;;;;;;;;;:::o;24727:1683::-;24919:14;24961:15;24991:16;25022;25053:21;25089:15;25119:11;25145:24;25183:44;25200:8;25210:9;25221:5;;25183:16;:44::i;:::-;24946:281;;;;;;;;;;;;;;25294:4;-1:-1:-1;;;;;25283:15:0;:7;-1:-1:-1;;;;;25283:15:0;;:33;;;-1:-1:-1;;;;;;25302:14:0;;17656:42;25302:14;25283:33;25279:887;;;25348:4;-1:-1:-1;;;;;25337:15:0;:7;-1:-1:-1;;;;;25337:15:0;;25333:46;;;25354:25;;-1:-1:-1;;;25354:25:0;;;;;11921::1;;;25360:4:0;-1:-1:-1;;;;;25354:20:0;;;;11894:18:1;;25354:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25333:46;25403:54;25409:14;25420:3;25409:8;:14;:::i;:::-;25425:13;25440:4;25446:10;25403:5;:54::i;:::-;25394:63;;25279:887;;;25491:4;-1:-1:-1;;;;;25479:16:0;:8;-1:-1:-1;;;;;25479:16:0;;:35;;;-1:-1:-1;;;;;;25499:15:0;;17656:42;25499:15;25479:35;25475:691;;;25540:57;25546:8;25556:19;25572:3;25556:13;:19;:::i;:::-;25577:4;25591;25540:5;:57::i;:::-;25531:66;;25628:4;-1:-1:-1;;;;;25616:16:0;:8;-1:-1:-1;;;;;25616:16:0;;25612:47;;;25634:25;;-1:-1:-1;;;25634:25:0;;;;;11921::1;;;25640:4:0;-1:-1:-1;;;;;25634:20:0;;;;11894:18:1;;25634:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25612:47;25674:43;25692:10;25704:12;25713:3;25704:6;:12;:::i;:::-;-1:-1:-1;;;;;25674:17:0;;;:43;:17;:43::i;:::-;25475:691;;;25750:19;25813:10;;25772:305;;-1:-1:-1;;;;;25813:10:0;25842:3;25886:8;25944:7;25978:4;26002:19;:15;25813:10;26002:19;:::i;:::-;25772:22;:305::i;:::-;25750:327;-1:-1:-1;26092:62:0;26098:22;25750:327;26098:8;:22;:::i;:::-;26122:13;26137:4;26143:10;26092:5;:62::i;:::-;;25475:691;;26211:19;26236:7;-1:-1:-1;;;;;26236:12:0;26256:3;26236:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26210:54;;;26297:14;26275:127;;;;-1:-1:-1;;;26275:127:0;;8862:2:1;26275:127:0;;;8844:21:1;8901:2;8881:18;;;8874:30;8940:34;8920:18;;;8913:62;9011:33;8991:18;;;8984:61;9062:19;;26275:127:0;8834:253:1;26275:127:0;24727:1683;;;;;;;;;;;;;;;;:::o;29075:796::-;29509:8;29548:9;29255:15;29347:21;29255:15;;29347:21;29648:32;-1:-1:-1;;;;;29648:17:0;;29674:4;29648:17;:32::i;:::-;29637:43;-1:-1:-1;29758:105:0;;;;29783:5;29758:105;:::i;:::-;29075:796;;;;-1:-1:-1;29075:796:0;;-1:-1:-1;29724:139:0;;-1:-1:-1;29724:139:0;-1:-1:-1;29724:139:0;;;29075:796;-1:-1:-1;;;;;29075:796:0:o;28474:323::-;28589:17;28654:10;;:79;;-1:-1:-1;;;28654:79:0;;28589:17;;-1:-1:-1;;;;;28654:10:0;;:24;;:79;;28693:9;;28717:5;;28654:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;28654:79:0;;;;;;;;;;;;:::i;:::-;28624:109;;28756:10;28787:1;28767:10;:17;:21;;;;:::i;:::-;28756:33;;;;;;-1:-1:-1;;;28756:33:0;;;;;;;;;;;;;;;28744:45;;28474:323;;;;;:::o;28805:262::-;28920:16;28983:10;;:42;;-1:-1:-1;;;28983:42:0;;28920:16;;-1:-1:-1;;;;;28983:10:0;;:23;;:42;;29007:10;;29019:5;;28983:42;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;28983:42:0;;;;;;;;;;;;:::i;:::-;28954:71;;29047:9;29057:1;29047:12;;;;;;-1:-1:-1;;;29047:12:0;;;;;;;;28019:447;28180:14;28265:10;;28216:242;;28246:4;;-1:-1:-1;;;;;28265:10:0;28290:9;28314:13;28342:5;28362:10;28387:19;:15;28265:10;28387:19;:::i;:::-;28216:15;:242::i;:::-;28207:251;28019:447;-1:-1:-1;;;;;28019:447:0:o;17852:224::-;-1:-1:-1;;;;;17971:13:0;;17656:42;17971:13;17967:101;;;17986:28;-1:-1:-1;;;;;17986:22:0;;18009:4;17986:22;:28::i;:::-;17852:224;;;:::o;17967:101::-;18030:38;-1:-1:-1;;;;;18030:27:0;;18058:3;18063:4;18030:27;:38::i;22638:818::-;22872:16;22897:118;22946:5;22952:1;22946:8;;;;;;-1:-1:-1;;;22946:8:0;;;;;;;;;;;;;;;22974:10;22996:12;22897:31;:118::i;:::-;23037:157;;-1:-1:-1;;;23037:157:0;;-1:-1:-1;;;;;23037:32:0;;;;;:157;;23084:10;;23109:12;;23136:5;;23156:3;;23174:9;;23037:157;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;23037:157:0;;;;;;;;;;;;:::i;:::-;;;23024:429;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;23316:61;23344:5;23316:61;;;;;;;;;;;;;;;;;:27;:61::i;:::-;23272:113;23024:429;;;;;23403:42;;-1:-1:-1;;;23403:42:0;;11616:2:1;23403:42:0;;;11598:21:1;;;11635:18;;;11628:30;11694:34;11674:18;;;11667:62;11746:18;;23403:42:0;11588:182:1;23024:429:0;23253:7;23261:1;23253:10;;;;;;-1:-1:-1;;;23253:10:0;;;;;;;;;;;;;;;23246:17;;;;;18084:259;18187:7;17656:42;-1:-1:-1;;;;;18232:13:0;;;:103;;18301:34;;-1:-1:-1;;;18301:34:0;;-1:-1:-1;;;;;6028:32:1;;;18301:34:0;;;6010:51:1;18301:24:0;;;;;5983:18:1;;18301:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;18232:103;;;18265:8;-1:-1:-1;;;;;18265:16:0;;18232:103;18212:123;18084:259;-1:-1:-1;;;18084:259:0:o;19263:1211::-;19521:7;17656:42;-1:-1:-1;;;;;19541:15:0;:5;19547:1;19541:8;;;;;;-1:-1:-1;;;19541:8:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;19541:15:0;;19537:286;;;19580:4;19569:5;19575:1;19569:8;;;;;;-1:-1:-1;;;19569:8:0;;;;;;;;;;;;;;:15;-1:-1:-1;;;;;19569:15:0;;;-1:-1:-1;;;;;19569:15:0;;;;;19615:200;19656:10;19685:9;19713:13;19745:5;19769:3;19791:9;19615:22;:200::i;:::-;19595:220;;;;19537:286;19831:115;19880:5;19886:1;19880:8;;;;;;-1:-1:-1;;;19880:8:0;;;;;;;;;;;;;;;19908:10;19930:9;19831:31;:115::i;:::-;17656:42;-1:-1:-1;;;;;19959:30:0;:5;19980:1;19965:5;:12;:16;;;;:::i;:::-;19959:23;;;;;;-1:-1:-1;;;19959:23:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;19959:30:0;;19955:316;;;20028:4;20002:5;20023:1;20008:5;:12;:16;;;;:::i;:::-;20002:23;;;;;;-1:-1:-1;;;20002:23:0;;;;;;;;;;;;;;:30;-1:-1:-1;;;;;20002:30:0;;;-1:-1:-1;;;;;20002:30:0;;;;;20063:200;20104:10;20133:9;20161:13;20193:5;20217:3;20239:9;20063:22;:200::i;19955:316::-;20295:175;20335:10;20360:9;20384:13;20412:5;20432:3;20450:9;20295:25;:175::i;:::-;20279:191;;19263:1211;;;;;;;;;;:::o;7891:317::-;8006:6;7981:21;:31;;7973:73;;;;-1:-1:-1;;;7973:73:0;;9721:2:1;7973:73:0;;;9703:21:1;9760:2;9740:18;;;9733:30;9799:31;9779:18;;;9772:59;9848:18;;7973:73:0;9693:179:1;7973:73:0;8060:12;8078:9;-1:-1:-1;;;;;8078:14:0;8100:6;8078:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8059:52;;;8130:7;8122:78;;;;-1:-1:-1;;;8122:78:0;;9294:2:1;8122:78:0;;;9276:21:1;9333:2;9313:18;;;9306:30;9372:34;9352:18;;;9345:62;9443:28;9423:18;;;9416:56;9489:19;;8122:78:0;9266:248:1;14291:211:0;14435:58;;-1:-1:-1;;;;;6573:32:1;;14435:58:0;;;6555:51:1;6622:18;;;6615:34;;;14408:86:0;;14428:5;;-1:-1:-1;;;14458:23:0;6528:18:1;;14435:58:0;;;;-1:-1:-1;;14435:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;14435:58:0;-1:-1:-1;;;;;;14435:58:0;;;;;;;;;;14408:19;:86::i;15651:317::-;15805:39;;-1:-1:-1;;;15805:39:0;;15829:4;15805:39;;;6284:34:1;-1:-1:-1;;;;;6354:15:1;;;6334:18;;;6327:43;15782:20:0;;15847:5;;15805:15;;;;;6219:18:1;;15805:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:47;;;;:::i;:::-;15890:69;;-1:-1:-1;;;;;6573:32:1;;15890:69:0;;;6555:51:1;6622:18;;;6615:34;;;15782:70:0;;-1:-1:-1;15863:97:0;;15883:5;;-1:-1:-1;;;15913:22:0;6528:18:1;;15890:69:0;6510:145:1;15863:97:0;15651:317;;;;:::o;18594:184::-;18747:12;18761:6;18730:38;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;18730:38:0;;;;;;;;;;-1:-1:-1;;;18716:54:0;;;;;;;:::i;20478:708::-;20712:17;20751:10;-1:-1:-1;;;;;20751:32:0;;20791:9;20816:13;20844:5;20864:3;20882:9;20751:151;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;20751:151:0;;;;;;;;;;;;:::i;:::-;;;20738:445;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;21046:61;21074:5;21046:61;;;;;;;;;;;;;;;;;:27;:61::i;20738:445::-;;;21133:42;;-1:-1:-1;;;21133:42:0;;8501:2:1;21133:42:0;;;8483:21:1;;;8520:18;;;8513:30;8579:34;8559:18;;;8552:62;8631:18;;21133:42:0;8473:182:1;20738:445:0;20966:7;20991:1;20974:7;:14;:18;;;;:::i;:::-;20966:27;;;;;;-1:-1:-1;;;20966:27:0;;;;;;;;;;;;;;;20954:39;;20908:93;20478:708;;;;;;;;:::o;21190:714::-;21463:157;;-1:-1:-1;;;21463:157:0;;21424:17;;-1:-1:-1;;;;;21463:32:0;;;;;:157;;21510:9;;21534:13;;21562:5;;21582:3;;21600:9;;21463:157;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;21463:157:0;;;;;;;;;;;;:::i;:::-;;;21450:451;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;21764:61;21792:5;21764:61;;;;;;;;;;;;;;;;;:27;:61::i;21450:451::-;;;21851:42;;-1:-1:-1;;;21851:42:0;;10486:2:1;21851:42:0;;;10468:21:1;;;10505:18;;;10498:30;10564:34;10544:18;;;10537:62;10616:18;;21851:42:0;10458:182:1;21908:726:0;22184:160;;-1:-1:-1;;;22184:160:0;;22145:17;;-1:-1:-1;;;;;22184:35:0;;;;;:160;;22234:9;;22258:13;;22286:5;;22306:3;;22324:9;;22184:160;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;22184:160:0;;;;;;;;;;;;:::i;:::-;;;22171:460;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;22488:64;22516:5;22488:64;;;;;;;;;;;;;;;;;:27;:64::i;22171:460::-;;;22578:45;;-1:-1:-1;;;22578:45:0;;7676:2:1;22578:45:0;;;7658:21:1;7715:2;7695:18;;;7688:30;7754:34;7734:18;;;7727:62;-1:-1:-1;;;7805:18:1;;;7798:33;7848:19;;22578:45:0;7648:225:1;16864:716:0;17288:23;17314:69;17342:4;17314:69;;;;;;;;;;;;;;;;;17322:5;-1:-1:-1;;;;;17314:27:0;;;:69;;;;;:::i;:::-;17398:17;;17288:95;;-1:-1:-1;17398:21:0;17394:179;;17495:10;17484:30;;;;;;;;;;;;:::i;:::-;17476:85;;;;-1:-1:-1;;;17476:85:0;;11205:2:1;17476:85:0;;;11187:21:1;11244:2;11224:18;;;11217:30;11283:34;11263:18;;;11256:62;-1:-1:-1;;;11334:18:1;;;11327:40;11384:19;;17476:85:0;11177:232:1;9375:229:0;9512:12;9544:52;9566:6;9574:4;9580:1;9583:12;9544:21;:52::i;:::-;9537:59;9375:229;-1:-1:-1;;;;9375:229:0:o;10495:511::-;10665:12;10723:5;10698:21;:30;;10690:81;;;;-1:-1:-1;;;10690:81:0;;10079:2:1;10690:81:0;;;10061:21:1;10118:2;10098:18;;;10091:30;10157:34;10137:18;;;10130:62;-1:-1:-1;;;10208:18:1;;;10201:36;10254:19;;10690:81:0;10051:228:1;10690:81:0;6892:20;;10782:60;;;;-1:-1:-1;;;10782:60:0;;10847:2:1;10782:60:0;;;10829:21:1;10886:2;10866:18;;;10859:30;10925:31;10905:18;;;10898:59;10974:18;;10782:60:0;10819:179:1;10782:60:0;10856:12;10870:23;10897:6;-1:-1:-1;;;;;10897:11:0;10916:5;10923:4;10897:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10855:73;;;;10946:52;10964:7;10973:10;10985:12;13114;13143:7;13139:530;;;-1:-1:-1;13174:10:0;13167:17;;13139:530;13288:17;;:21;13284:374;;13486:10;13480:17;13547:15;13534:10;13530:2;13526:19;13519:44;13434:148;13629:12;13622:20;;-1:-1:-1;;;13622:20:0;;;;;;;;:::i;14:830:1:-;68:5;121:3;114:4;106:6;102:17;98:27;88:2;;143:5;136;129:20;88:2;183:6;170:20;209:4;232:43;272:2;232:43;:::i;:::-;304:2;298:9;316:31;344:2;336:6;316:31;:::i;:::-;382:18;;;416:15;;;;-1:-1:-1;451:15:1;;;501:1;497:10;;;485:23;;481:32;;478:41;-1:-1:-1;475:2:1;;;536:5;529;522:20;475:2;562:5;576:238;590:2;587:1;584:9;576:238;;;661:3;648:17;678:31;703:5;678:31;:::i;:::-;722:18;;760:12;;;;792;;;;608:1;601:9;576:238;;;-1:-1:-1;832:6:1;;78:766;-1:-1:-1;;;;;;;78:766:1:o;849:987::-;1010:6;1018;1026;1034;1042;1095:3;1083:9;1074:7;1070:23;1066:33;1063:2;;;1117:6;1109;1102:22;1063:2;1161:9;1148:23;1180:31;1205:5;1180:31;:::i;:::-;1230:5;-1:-1:-1;1287:2:1;1272:18;;1259:32;1300:33;1259:32;1300:33;:::i;:::-;1352:7;-1:-1:-1;1406:2:1;1391:18;;1378:32;;-1:-1:-1;1461:2:1;1446:18;;1433:32;1484:18;1514:14;;;1511:2;;;1546:6;1538;1531:22;1511:2;1574:61;1627:7;1618:6;1607:9;1603:22;1574:61;:::i;:::-;1564:71;;1688:3;1677:9;1673:19;1660:33;1644:49;;1718:2;1708:8;1705:16;1702:2;;;1739:6;1731;1724:22;1702:2;;1767:63;1822:7;1811:8;1800:9;1796:24;1767:63;:::i;:::-;1757:73;;;1053:783;;;;;;;;:::o;1841:999::-;1936:6;1967:2;2010;1998:9;1989:7;1985:23;1981:32;1978:2;;;2031:6;2023;2016:22;1978:2;2069:9;2063:16;2102:18;2094:6;2091:30;2088:2;;;2139:6;2131;2124:22;2088:2;2167:22;;2220:4;2212:13;;2208:27;-1:-1:-1;2198:2:1;;2254:6;2246;2239:22;2198:2;2288;2282:9;2310:43;2350:2;2310:43;:::i;:::-;2382:2;2376:9;2394:31;2422:2;2414:6;2394:31;:::i;:::-;2460:18;;;2494:15;;;;-1:-1:-1;2529:11:1;;;2571:1;2567:10;;;2559:19;;2555:28;;2552:41;-1:-1:-1;2549:2:1;;;2611:6;2603;2596:22;2549:2;2638:6;2629:15;;2653:156;2667:2;2664:1;2661:9;2653:156;;;2724:10;;2712:23;;2685:1;2678:9;;;;;2755:12;;;;2787;;2653:156;;;-1:-1:-1;2828:6:1;1947:893;-1:-1:-1;;;;;;;1947:893:1:o;2845:297::-;2912:6;2965:2;2953:9;2944:7;2940:23;2936:32;2933:2;;;2986:6;2978;2971:22;2933:2;3023:9;3017:16;3076:5;3069:13;3062:21;3055:5;3052:32;3042:2;;3103:6;3095;3088:22;3147:1081;3279:6;3287;3295;3303;3311;3319;3372:3;3360:9;3351:7;3347:23;3343:33;3340:2;;;3394:6;3386;3379:22;3340:2;3438:9;3425:23;3457:31;3482:5;3457:31;:::i;:::-;3507:5;-1:-1:-1;3564:2:1;3549:18;;3536:32;3577:33;3536:32;3577:33;:::i;:::-;3629:7;-1:-1:-1;3683:2:1;3668:18;;3655:32;;-1:-1:-1;3734:2:1;3719:18;;3706:32;;-1:-1:-1;3789:3:1;3774:19;;3761:33;3813:18;3843:14;;;3840:2;;;3875:6;3867;3860:22;3840:2;3918:6;3907:9;3903:22;3893:32;;3963:7;3956:4;3952:2;3948:13;3944:27;3934:2;;3990:6;3982;3975:22;3934:2;4035;4022:16;4061:2;4053:6;4050:14;4047:2;;;4082:6;4074;4067:22;4047:2;4132:7;4127:2;4118:6;4114:2;4110:15;4106:24;4103:37;4100:2;;;4158:6;4150;4143:22;4100:2;4194;4190;4186:11;4176:21;;4216:6;4206:16;;;;;3330:898;;;;;;;;:::o;4233:194::-;4303:6;4356:2;4344:9;4335:7;4331:23;4327:32;4324:2;;;4377:6;4369;4362:22;4324:2;-1:-1:-1;4405:16:1;;4314:113;-1:-1:-1;4314:113:1:o;4432:463::-;4485:3;4523:5;4517:12;4550:6;4545:3;4538:19;4576:4;4605:2;4600:3;4596:12;4589:19;;4642:2;4635:5;4631:14;4663:3;4675:195;4689:6;4686:1;4683:13;4675:195;;;4754:13;;-1:-1:-1;;;;;4750:39:1;4738:52;;4810:12;;;;4845:15;;;;4786:1;4704:9;4675:195;;;-1:-1:-1;4886:3:1;;4493:402;-1:-1:-1;;;;;4493:402:1:o;4900:274::-;5029:3;5067:6;5061:13;5083:53;5129:6;5124:3;5117:4;5109:6;5105:17;5083:53;:::i;:::-;5152:16;;;;;5037:137;-1:-1:-1;;5037:137:1:o;5179:470::-;5358:3;5396:6;5390:13;5412:53;5458:6;5453:3;5446:4;5438:6;5434:17;5412:53;:::i;:::-;5528:13;;5487:16;;;;5550:57;5528:13;5487:16;5584:4;5572:17;;5550:57;:::i;:::-;5623:20;;5366:283;-1:-1:-1;;;;5366:283:1:o;7086:383::-;7235:2;7224:9;7217:21;7198:4;7267:6;7261:13;7310:6;7305:2;7294:9;7290:18;7283:34;7326:66;7385:6;7380:2;7369:9;7365:18;7360:2;7352:6;7348:15;7326:66;:::i;:::-;7453:2;7432:15;-1:-1:-1;;7428:29:1;7413:45;;;;7460:2;7409:54;;7207:262;-1:-1:-1;;7207:262:1:o;11957:332::-;12164:6;12153:9;12146:25;12207:2;12202;12191:9;12187:18;12180:30;12127:4;12227:56;12279:2;12268:9;12264:18;12256:6;12227:56;:::i;12294:502::-;12557:6;12546:9;12539:25;12600:3;12595:2;12584:9;12580:18;12573:31;12520:4;12621:57;12673:3;12662:9;12658:19;12650:6;12621:57;:::i;:::-;-1:-1:-1;;;;;12714:32:1;;;;12709:2;12694:18;;12687:60;-1:-1:-1;12778:2:1;12763:18;12756:34;12613:65;12529:267;-1:-1:-1;;12529:267:1:o;12801:574::-;13092:6;13081:9;13074:25;13135:6;13130:2;13119:9;13115:18;13108:34;13178:3;13173:2;13162:9;13158:18;13151:31;13055:4;13199:57;13251:3;13240:9;13236:19;13228:6;13199:57;:::i;:::-;-1:-1:-1;;;;;13292:32:1;;;;13287:2;13272:18;;13265:60;-1:-1:-1;13356:3:1;13341:19;13334:35;13191:65;13064:311;-1:-1:-1;;;13064:311:1:o;13380:183::-;13440:4;13473:18;13465:6;13462:30;13459:2;;;13495:18;;:::i;:::-;-1:-1:-1;13540:1:1;13536:14;13552:4;13532:25;;13449:114::o;13568:128::-;13608:3;13639:1;13635:6;13632:1;13629:13;13626:2;;;13645:18;;:::i;:::-;-1:-1:-1;13681:9:1;;13616:80::o;13701:125::-;13741:4;13769:1;13766;13763:8;13760:2;;;13774:18;;:::i;:::-;-1:-1:-1;13811:9:1;;13750:76::o;13831:258::-;13903:1;13913:113;13927:6;13924:1;13921:13;13913:113;;;14003:11;;;13997:18;13984:11;;;13977:39;13949:2;13942:10;13913:113;;;14044:6;14041:1;14038:13;14035:2;;;-1:-1:-1;;14079:1:1;14061:16;;14054:27;13884:205::o;14094:249::-;14204:2;14185:13;;-1:-1:-1;;14181:27:1;14169:40;;14239:18;14224:34;;14260:22;;;14221:62;14218:2;;;14286:18;;:::i;:::-;14322:2;14315:22;-1:-1:-1;;14141:202:1:o;14348:127::-;14409:10;14404:3;14400:20;14397:1;14390:31;14440:4;14437:1;14430:15;14464:4;14461:1;14454:15;14480:127;14541:10;14536:3;14532:20;14529:1;14522:31;14572:4;14569:1;14562:15;14596:4;14593:1;14586:15;14612:185;14647:3;14689:1;14671:16;14668:23;14665:2;;;14739:1;14734:3;14729;14714:27;14770:10;14765:3;14761:20;14665:2;14655:142;:::o;14802:671::-;14841:3;14883:4;14865:16;14862:26;14859:2;;;14849:624;:::o;14859:2::-;14925;14919:9;-1:-1:-1;;14990:16:1;14986:25;;14983:1;14919:9;14962:50;15041:4;15035:11;15065:16;15100:18;15171:2;15164:4;15156:6;15152:17;15149:25;15144:2;15136:6;15133:14;15130:45;15127:2;;;15178:5;;;;;14849:624;:::o;15127:2::-;15215:6;15209:4;15205:17;15194:28;;15251:3;15245:10;15278:2;15270:6;15267:14;15264:2;;;15284:5;;;;;;14849:624;:::o;15264:2::-;15368;15349:16;15343:4;15339:27;15335:36;15328:4;15319:6;15314:3;15310:16;15306:27;15303:69;15300:2;;;15375:5;;;;;;14849:624;:::o;15300:2::-;15391:57;15442:4;15433:6;15425;15421:19;15417:30;15411:4;15391:57;:::i;:::-;-1:-1:-1;15464:3:1;;14849:624;-1:-1:-1;;;;;14849:624:1:o;15478:131::-;-1:-1:-1;;;;;15553:31:1;;15543:42;;15533:2;;15599:1;15596;15589:12;15533:2;15523:86;:::o

ipfs://fcef35cfec520c2921eb7e00e4e4c2bf22a5727cd1288198d094a725c850164c