Contract 0x58bca4676e37e50c0dfb1f419718ed89a09ad981 1

// SPDX-License-Identifier: None
pragma solidity 0.8.4;

import './Ownable.sol';
import './Address.sol';
import './SafeMath.sol';
import './ACOAssetHelper.sol';
import './IACOAssetConverterHelper.sol';
import './IUniswapV2Router02.sol';
import './AggregatorV3Interface.sol';
import './IWETH.sol';

contract ACOAssetConverterHelper is Ownable, IACOAssetConverterHelper {
    using Address for address;
    using SafeMath for uint256;

    uint256 public constant PERCENTAGE_PRECISION = 100000;
    
    struct PairData {
        bool initialized;
        address aggregator;
        uint256 aggregatorPrecision;
        uint256 tolerancePercentage;
        address[] uniswapMiddleRoute;
    }

    event SetAggregator(address indexed baseAsset, address indexed quoteAsset, address previousAggregator, address newAggregator);
    event SetUniswapMiddleRoute(address indexed baseAsset, address indexed quoteAsset, address[] previousUniswapMiddleRoute, address[] newUniswapMiddleRoute);
	event SetPairTolerancePercentage(address indexed baseAsset, address indexed quoteAsset, uint256 oldTolerancePercentage, uint256 newTolerancePercentage);
    IUniswapV2Router02 public immutable uniswapRouter;
    

    address public immutable WETH;


    mapping(address => mapping(address => PairData)) internal pairs; 
    mapping(address => uint256) public assetPrecision;
    
    constructor(address _uniswapRouter) {
		super.init();
		
		uniswapRouter = IUniswapV2Router02(_uniswapRouter);
		WETH = IUniswapV2Router02(_uniswapRouter).WETH();
    }
    
    receive() external payable {
        require(msg.sender != tx.origin, "ACOAssetConverterHelper:: Only contracts can send ether");
    }

    function setPairTolerancePercentage(address baseAsset, address quoteAsset, uint256 tolerancePercentage) onlyOwner public override {
        require(tolerancePercentage <= PERCENTAGE_PRECISION, "ACOAssetConverterHelper:: Invalid tolerance percentage");
        (bool reversed, PairData storage data) = _getPair(baseAsset, quoteAsset, false);
        if (data.initialized) {
			if (reversed) {
				emit SetPairTolerancePercentage(quoteAsset, baseAsset, data.tolerancePercentage, tolerancePercentage);
			} else {
				emit SetPairTolerancePercentage(baseAsset, quoteAsset, data.tolerancePercentage, tolerancePercentage);
			}
            data.tolerancePercentage = tolerancePercentage;
        } else {
			emit SetPairTolerancePercentage(baseAsset, quoteAsset, 0, tolerancePercentage);
            _createPair(baseAsset, quoteAsset, address(0), 0, tolerancePercentage, new address[](0));
        }
    }

    function setAggregator(address baseAsset, address quoteAsset, address aggregator) onlyOwner public override {
        require(aggregator.isContract(), "ACOAssetConverterHelper:: Invalid aggregator");
        uint256 aggregatorPrecision = (10 ** uint256(AggregatorV3Interface(aggregator).decimals()));
        (bool reversed, PairData storage data) = _getPair(baseAsset, quoteAsset, false);
        if (data.initialized) {
			if (reversed) {
				emit SetAggregator(quoteAsset, baseAsset, data.aggregator, aggregator);
			} else {
				emit SetAggregator(baseAsset, quoteAsset, data.aggregator, aggregator);
			}
            data.aggregator = aggregator;
            data.aggregatorPrecision = aggregatorPrecision;
        } else {
			emit SetAggregator(baseAsset, quoteAsset, address(0), aggregator);
            _createPair(baseAsset, quoteAsset, aggregator, aggregatorPrecision, 0, new address[](0));
        }
    }

    function setUniswapMiddleRoute(address baseAsset, address quoteAsset, address[] memory uniswapMiddleRoute) onlyOwner public override {
        _validateUniswapMiddleRoute(baseAsset, quoteAsset, uniswapMiddleRoute);
        (bool reversed, PairData storage data) = _getPair(baseAsset, quoteAsset, false);
        if (data.initialized) {
            if (reversed) {
                address[] memory route = new address[](uniswapMiddleRoute.length);
                uint256 index = 0;
                for (uint256 i = uniswapMiddleRoute.length; i > 0; --i) {
                    route[index] = uniswapMiddleRoute[i-1];
                    ++index;
                }
				emit SetUniswapMiddleRoute(quoteAsset, baseAsset, data.uniswapMiddleRoute, route);
                delete data.uniswapMiddleRoute;
                data.uniswapMiddleRoute = route;
            } else {
				emit SetUniswapMiddleRoute(baseAsset, quoteAsset, data.uniswapMiddleRoute, uniswapMiddleRoute);
                delete data.uniswapMiddleRoute;
                data.uniswapMiddleRoute = uniswapMiddleRoute;
            }
        } else {
			emit SetUniswapMiddleRoute(baseAsset, quoteAsset, new address[](0), uniswapMiddleRoute);
            _createPair(baseAsset, quoteAsset, address(0), 0, 0, uniswapMiddleRoute);
        }
    }

    function withdrawStuckAsset(address asset, address destination) onlyOwner public override {
        uint256 amount = ACOAssetHelper._getAssetBalanceOf(asset, address(this));
        if (amount > 0) {
            ACOAssetHelper._transferAsset(asset, destination, amount);
        }
    }

    function hasAggregator(address baseAsset, address quoteAsset) public override view returns(bool) {
        (,PairData storage data) = _getPair(baseAsset, quoteAsset, false);
        return (data.aggregator != address(0));
    }

    function getPairData(address baseAsset, address quoteAsset) public override view returns(address, uint256, uint256, uint256) {
        (,PairData storage data) = _getPair(baseAsset, quoteAsset, false);
        return (data.aggregator, data.aggregatorPrecision, data.tolerancePercentage, data.uniswapMiddleRoute.length);
    }

    function getUniswapMiddleRouteByIndex(address baseAsset, address quoteAsset, uint256 index) public override view returns(address) {
        (bool reversed, PairData memory data) = _getPair(baseAsset, quoteAsset, false);
        if (reversed) {
            if (index >= data.uniswapMiddleRoute.length) {
                return address(0);
            } else {
                return data.uniswapMiddleRoute[(data.uniswapMiddleRoute.length - index - 1)];    
            }
        } else {
            return data.uniswapMiddleRoute[index];
        }
    }

    function getPrice(address baseAsset, address quoteAsset) public override view returns(uint256) {
        (uint256 price,) = _getAggregatorPriceAndTolerance(baseAsset, quoteAsset);  
        return price;
    }

    function getPriceWithTolerance(address baseAsset, address quoteAsset, bool isMinimumPrice) public override view returns(uint256) {
        (uint256 price, uint256 tolerancePercentage) = _getAggregatorPriceAndTolerance(baseAsset, quoteAsset);
        return _getPriceWithTolerance(price, tolerancePercentage, isMinimumPrice);
    }

    function getExpectedAmountOutToSwapExactAmountIn(address assetToSold, address assetToBuy, uint256 amountToBuy) public override view returns(uint256) {
        (bool reversed, PairData storage data) = _getPair(assetToSold, assetToBuy, true);
        return _getMaxAmountToSoldToSwapExactAmountIn(assetToSold, assetToBuy, amountToBuy, data.tolerancePercentage, reversed, data);
    }

    function getExpectedAmountOutToSwapExactAmountInWithSpecificTolerance(address assetToSold, address assetToBuy, uint256 amountToBuy, uint256 tolerancePercentage) public override view returns(uint256) {
        (bool reversed, PairData storage data) = _getPair(assetToSold, assetToBuy, true);
        return _getMaxAmountToSoldToSwapExactAmountIn(assetToSold, assetToBuy, amountToBuy, tolerancePercentage, reversed, data);
    }

    function swapExactAmountOut(address assetToSold, address assetToBuy, uint256 amountToSold) public payable override returns(uint256) {
        (bool reversed, PairData storage data) = _getPair(assetToSold, assetToBuy, true);
        return _swapExactAmountOut(assetToSold, assetToBuy, amountToSold, data.tolerancePercentage, reversed, data);
    }

    function swapExactAmountOutWithSpecificTolerance(address assetToSold, address assetToBuy, uint256 amountToSold, uint256 tolerancePercentage) public payable override returns(uint256) {
        require(tolerancePercentage <= PERCENTAGE_PRECISION, "ACOAssetConverterHelper:: Invalid tolerance percentage");
        (bool reversed, PairData storage data) = _getPair(assetToSold, assetToBuy, true);
        return _swapExactAmountOut(assetToSold, assetToBuy, amountToSold, tolerancePercentage, reversed, data);
    }

    function swapExactAmountOutWithMinAmountToReceive(address assetToSold, address assetToBuy, uint256 amountToSold, uint256 minAmountToReceive) public payable override returns(uint256) {
        (bool reversed, PairData storage data) = _getPair(assetToSold, assetToBuy, false);
        _setAsset(assetToSold);
        return _swapExactAmountOutWithMinAmountToReceive(assetToSold, assetToBuy, amountToSold, minAmountToReceive, reversed, data.uniswapMiddleRoute);
    }

    function swapExactAmountIn(address assetToSold, address assetToBuy, uint256 amountToBuy) public payable override returns(uint256) {
        (bool reversed, PairData storage data) = _getPair(assetToSold, assetToBuy, true);
        return _swapExactAmountIn(assetToSold, assetToBuy, amountToBuy, data.tolerancePercentage, reversed, data);
    }

    function swapExactAmountInWithSpecificTolerance(address assetToSold, address assetToBuy, uint256 amountToBuy, uint256 tolerancePercentage) public payable override returns(uint256) {
        require(tolerancePercentage <= PERCENTAGE_PRECISION, "ACOAssetConverterHelper:: Invalid tolerance percentage");
        (bool reversed, PairData storage data) = _getPair(assetToSold, assetToBuy, true);
        return _swapExactAmountIn(assetToSold, assetToBuy, amountToBuy, tolerancePercentage, reversed, data);
    }

    function swapExactAmountInWithMaxAmountToSold(address assetToSold, address assetToBuy, uint256 amountToBuy, uint256 maxAmountToSold) public payable override returns(uint256) {
        (bool reversed, PairData storage data) = _getPair(assetToSold, assetToBuy, false);
        _setAsset(assetToSold);
        return _swapExactAmountInWithMaxAmountToSold(assetToSold, assetToBuy, amountToBuy, maxAmountToSold, reversed, data.uniswapMiddleRoute);
    }

    function _swapExactAmountIn(
        address assetToSold, 
        address assetToBuy, 
        uint256 amount, 
        uint256 tolerancePercentage,
        bool reversed,
        PairData storage data
    ) internal returns(uint256) {
        uint256 maxAmountToSold = _getMaxAmountToSoldToSwapExactAmountIn(
            assetToSold,
            assetToBuy,
            amount,
            tolerancePercentage,
            reversed,
            data
        );
        return _swapExactAmountInWithMaxAmountToSold(assetToSold, assetToBuy, amount, maxAmountToSold, reversed, data.uniswapMiddleRoute);
    }

    function _getMaxAmountToSoldToSwapExactAmountIn(
        address assetToSold, 
        address assetToBuy, 
        uint256 amount, 
        uint256 tolerancePercentage,
        bool reversed,
        PairData storage data
    ) internal view returns(uint256) {
        uint256 price = _getPriceWithTolerance(_getAggregatorPriceValue(assetToBuy, reversed, data), tolerancePercentage, true);
        return amount.mul(assetPrecision[assetToSold]).div(price);
    }

    function _swapExactAmountInWithMaxAmountToSold(
        address assetToSold, 
        address assetToBuy, 
        uint256 amountToBuy, 
        uint256 maxAmountToSold,
        bool reversed,
        address[] storage uniswapMiddleRoute
    ) internal returns(uint256) {
        uint256 previousAmount = ACOAssetHelper._getAssetBalanceOf(assetToSold, address(this));
        
        if (ACOAssetHelper._isEther(assetToSold)) {
            previousAmount = previousAmount.sub(msg.value);
            require(msg.value >= maxAmountToSold, "ACOAssetConverterHelper:: Invalid ETH amount");
        } else {
            require(msg.value == 0, "ACOAssetConverterHelper:: Ether is not expected");
            ACOAssetHelper._callTransferFromERC20(assetToSold, msg.sender, address(this), maxAmountToSold);
        }

        _swapAssetsExactAmountIn(assetToSold, assetToBuy, amountToBuy, maxAmountToSold, reversed, uniswapMiddleRoute);
        
        uint256 afterAmount = ACOAssetHelper._getAssetBalanceOf(assetToSold, address(this));
        uint256 remaining = afterAmount.sub(previousAmount);
        if (remaining > 0) {
            ACOAssetHelper._transferAsset(assetToSold, msg.sender, remaining);
        }
        ACOAssetHelper._transferAsset(assetToBuy, msg.sender, amountToBuy);
        return maxAmountToSold.sub(remaining);
    }

    function _swapExactAmountOut(
        address assetToSold, 
        address assetToBuy, 
        uint256 amount, 
        uint256 tolerancePercentage,
        bool reversed,
        PairData storage data
    ) internal returns(uint256) {
        uint256 price = _getPriceWithTolerance(_getAggregatorPriceValue(assetToBuy, reversed, data), tolerancePercentage, true);
        uint256 minAmountToReceive = price.mul(amount).div(assetPrecision[assetToSold]);
        
        return _swapExactAmountOutWithMinAmountToReceive(assetToSold, assetToBuy, amount, minAmountToReceive, reversed, data.uniswapMiddleRoute);
    }

    function _swapExactAmountOutWithMinAmountToReceive(
        address assetToSold, 
        address assetToBuy, 
        uint256 amountToSold, 
        uint256 minAmountToReceive,
        bool reversed,
        address[] storage uniswapMiddleRoute
    ) internal returns(uint256) {
        ACOAssetHelper._receiveAsset(assetToSold, amountToSold);
        
        uint256 previousAmount = ACOAssetHelper._getAssetBalanceOf(assetToBuy, address(this));
        
        _swapAssetsExactAmountOut(assetToSold, assetToBuy, amountToSold, minAmountToReceive, reversed, uniswapMiddleRoute);
        
        uint256 afterAmount = ACOAssetHelper._getAssetBalanceOf(assetToBuy, address(this));
        uint256 purchased = afterAmount.sub(previousAmount);
        ACOAssetHelper._transferAsset(assetToBuy, msg.sender, purchased);
        return purchased;
    }

    function _validateUniswapMiddleRoute(address asset0, address asset1, address[] memory uniswapMiddleRoute) internal pure {
        for (uint256 i = 0; i < uniswapMiddleRoute.length; ++i) {
            address asset = uniswapMiddleRoute[i];
            require(asset0 != asset && asset1 != asset, "ACOAssetConverterHelper:: Invalid middle route");
            for (uint256 j = i+1; j < uniswapMiddleRoute.length; ++j) {
                require(asset != uniswapMiddleRoute[j], "ACOAssetConverterHelper:: Invalid middle route");
            }
        }
    }

    function _getPriceWithTolerance(uint256 price, uint256 tolerancePercentage, bool isMinimumPrice) internal pure returns(uint256) {
        if (isMinimumPrice) {
            return price.mul(PERCENTAGE_PRECISION.sub(tolerancePercentage)).div(PERCENTAGE_PRECISION);
        } else {
            return price.mul(PERCENTAGE_PRECISION.add(tolerancePercentage)).div(PERCENTAGE_PRECISION);    
        }
    }

    function _getPair(address baseAsset, address quoteAsset, bool validateAggregatorExistence) internal view returns(bool, PairData storage) {
        PairData storage data = pairs[baseAsset][quoteAsset];
        if (data.initialized) {
			require(!validateAggregatorExistence || data.aggregator != address(0), "ACOAssetConverterHelper:: No aggregator");
            return (false, data);
        } else {
			PairData storage data2 = pairs[quoteAsset][baseAsset];
			require(!validateAggregatorExistence || data2.aggregator != address(0), "ACOAssetConverterHelper:: No aggregator");
			return (data2.initialized, data2);
		}
    }

    function _getAggregatorPriceAndTolerance(address baseAsset, address quoteAsset) internal view returns(uint256, uint256) {
        (bool reversed, PairData storage data) = _getPair(baseAsset, quoteAsset, true);
        uint256 price = _getAggregatorPriceValue(quoteAsset, reversed, data);
        return (price, data.tolerancePercentage);
    }

    function _getAggregatorPriceValue(address quoteAsset, bool reversed, PairData storage data) internal view returns(uint256) {
        (,int256 answer,,,) = AggregatorV3Interface(data.aggregator).latestRoundData();
        
        uint256 _aggregatorPrecision = data.aggregatorPrecision;
        uint256 _assetPrecision = assetPrecision[quoteAsset];
        
        if (reversed) {
            return _aggregatorPrecision.mul(_assetPrecision).div(uint256(answer));
        } else if (_aggregatorPrecision > _assetPrecision) {
            return uint256(answer).div(_aggregatorPrecision.div(_assetPrecision));
        } else {
            return uint256(answer).mul(_assetPrecision).div(_aggregatorPrecision);
        }
    }

	function _createPair(
	    address baseAsset,
	    address quoteAsset,
	    address aggregator, 
	    uint256 aggregatorPrecision,
	    uint256 tolerancePercentage, 
	    address[] memory uniswapMiddleRoute
    ) internal {
        require(baseAsset != quoteAsset, "ACOAssetConverterHelper:: Invalid assets");
        require(ACOAssetHelper._isEther(baseAsset) || baseAsset.isContract(), "ACOAssetConverterHelper:: Invalid base asset");
        require(ACOAssetHelper._isEther(quoteAsset) || quoteAsset.isContract(), "ACOAssetConverterHelper:: Invalid quote asset");
        
        _setAsset(baseAsset);
        _setAsset(quoteAsset);
        
        pairs[baseAsset][quoteAsset] = PairData(true, aggregator, aggregatorPrecision, tolerancePercentage, uniswapMiddleRoute);
    }

    function _setAsset(address asset) internal {
        if (assetPrecision[asset] == 0) {
            uint256 decimals = ACOAssetHelper._getAssetDecimals(asset);
            assetPrecision[asset] = (10 ** decimals);
            if (!ACOAssetHelper._isEther(asset)) {
                ACOAssetHelper._callApproveERC20(asset, address(uniswapRouter), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            }
        }
    }

	function _getUniswapRouterPath(address assetOut, address assetIn, bool reversed, address[] storage uniswapMiddleRoute) internal view returns(address[] memory) {
        address[] memory path = new address[](2 + uniswapMiddleRoute.length);
        address end;
        if (ACOAssetHelper._isEther(assetOut)) {
            path[0] = WETH;
            end = assetIn;
        } else if (ACOAssetHelper._isEther(assetIn)) {
            path[0] = assetOut;
            end = WETH;
        } else {
            path[0] = assetOut;
            end = assetIn;
        }
        uint256 index = 1;
        uint256 i = (uniswapMiddleRoute.length > 0 && reversed ? (uniswapMiddleRoute.length - 1) : 0);
        while (i < uniswapMiddleRoute.length && i >= 0) {
            path[index] = uniswapMiddleRoute[i];
            ++index;
            if (reversed) {
                if (i == 0) {
                    break;
                }
                --i;
            } else {
                ++i;
            }
        }
        path[index] = end;
        return path;
	}
	
    function _swapAssetsExactAmountOut(
        address assetOut, 
        address assetIn, 
        uint256 amountOut, 
        uint256 minAmountIn,
        bool reversed,
        address[] storage uniswapMiddleRoute
    ) internal {
        address[] memory path = _getUniswapRouterPath(assetOut, assetIn, reversed, uniswapMiddleRoute);
        if (ACOAssetHelper._isEther(assetOut)) {
            uniswapRouter.swapExactETHForTokens{value: amountOut}(minAmountIn, path, address(this), block.timestamp);
        } else if (ACOAssetHelper._isEther(assetIn)) {
            uniswapRouter.swapExactTokensForETH(amountOut, minAmountIn, path, address(this), block.timestamp);
        } else {
            uniswapRouter.swapExactTokensForTokens(amountOut, minAmountIn, path, address(this), block.timestamp);
        }
    }

    function _swapAssetsExactAmountIn(
        address assetOut, 
        address assetIn, 
        uint256 amountIn, 
        uint256 maxAmountOut, 
        bool reversed,
        address[] storage uniswapMiddleRoute
    ) internal {
        address[] memory path = _getUniswapRouterPath(assetOut, assetIn, reversed, uniswapMiddleRoute);
        if (ACOAssetHelper._isEther(assetOut)) {
            uniswapRouter.swapETHForExactTokens{value: maxAmountOut}(amountIn, path, address(this), block.timestamp);
        } else if (ACOAssetHelper._isEther(assetIn)) {
            uniswapRouter.swapTokensForExactETH(amountIn, maxAmountOut, path, address(this), block.timestamp);
        } else {
            uniswapRouter.swapTokensForExactTokens(amountIn, maxAmountOut, path, address(this), block.timestamp);
        }
    }
}

// SPDX-License-Identifier: None
pragma solidity 0.8.4;

library ACOAssetHelper {
    uint256 internal constant MAX_UINT = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;

    function _isEther(address _address) internal pure returns(bool) {
        return _address == address(0);
    }

    function _callApproveERC20(address token, address spender, uint256 amount) internal {
        (bool success, bytes memory returndata) = token.call(abi.encodeWithSelector(0x095ea7b3, spender, amount));
        require(success && (returndata.length == 0 || abi.decode(returndata, (bool))), "approve");
    }

    function _callTransferERC20(address token, address recipient, uint256 amount) internal {
        (bool success, bytes memory returndata) = token.call(abi.encodeWithSelector(0xa9059cbb, recipient, amount));
        require(success && (returndata.length == 0 || abi.decode(returndata, (bool))), "transfer");
    }

     function _callTransferFromERC20(address token, address sender, address recipient, uint256 amount) internal {
        (bool success, bytes memory returndata) = token.call(abi.encodeWithSelector(0x23b872dd, sender, recipient, amount));
        require(success && (returndata.length == 0 || abi.decode(returndata, (bool))), "transferFrom");
    }

    function _getAssetSymbol(address asset) internal view returns(string memory) {
        if (_isEther(asset)) {
            return "ETH";
        } else {
            (bool success, bytes memory returndata) = asset.staticcall(abi.encodeWithSelector(0x95d89b41));
            require(success, "symbol");
            return abi.decode(returndata, (string));
        }
    }

    function _getAssetDecimals(address asset) internal view returns(uint8) {
        if (_isEther(asset)) {
            return uint8(18);
        } else {
            (bool success, bytes memory returndata) = asset.staticcall(abi.encodeWithSelector(0x313ce567));
            require(success, "decimals");
            return abi.decode(returndata, (uint8));
        }
    }

    function _getAssetName(address asset) internal view returns(string memory) {
        if (_isEther(asset)) {
            return "Ethereum";
        } else {
            (bool success, bytes memory returndata) = asset.staticcall(abi.encodeWithSelector(0x06fdde03));
            require(success, "name");
            return abi.decode(returndata, (string));
        }
    }

    function _getAssetBalanceOf(address asset, address account) internal view returns(uint256) {
        if (_isEther(asset)) {
            return account.balance;
        } else {
            (bool success, bytes memory returndata) = asset.staticcall(abi.encodeWithSelector(0x70a08231, account));
            require(success, "balanceOf");
            return abi.decode(returndata, (uint256));
        }
    }

    function _getAssetAllowance(address asset, address owner, address spender) internal view returns(uint256) {
        if (_isEther(asset)) {
            return 0;
        } else {
            (bool success, bytes memory returndata) = asset.staticcall(abi.encodeWithSelector(0xdd62ed3e, owner, spender));
            require(success, "allowance");
            return abi.decode(returndata, (uint256));
        }
    }

    function _transferAsset(address asset, address to, uint256 amount) internal {
        if (_isEther(asset)) {
            (bool success,) = to.call{value:amount}(new bytes(0));
            require(success, "send");
        } else {
            _callTransferERC20(asset, to, amount);
        }
    }

    function _receiveAsset(address asset, uint256 amount) internal {
        if (_isEther(asset)) {
            require(msg.value == amount, "Invalid ETH amount");
        } else {
            require(msg.value == 0, "No payable");
            _callTransferFromERC20(asset, msg.sender, address(this), amount);
        }
    }

    function _setAssetInfinityApprove(address asset, address owner, address spender, uint256 amount) internal {
        if (_getAssetAllowance(asset, owner, spender) < amount) {
            _callApproveERC20(asset, spender, MAX_UINT);
        }
    }
}

// Contract on https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts
// SPDX-License-Identifier: MIT
pragma solidity 0.8.4;

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

// SPDX-License-Identifier: None
pragma solidity 0.8.4;

interface AggregatorV3Interface {

  function decimals() external view returns (uint8);
  function description() external view returns (string memory);
  function version() external view returns (uint256);

  // getRoundData and latestRoundData should both raise "No data present"
  // if they do not have data to report, instead of returning unset values
  // which could be misinterpreted as actual reported values.
  function getRoundData(uint80 _roundId)
    external
    view
    returns (
      uint80 roundId,
      int256 answer,
      uint256 startedAt,
      uint256 updatedAt,
      uint80 answeredInRound
    );
  function latestRoundData()
    external
    view
    returns (
      uint80 roundId,
      int256 answer,
      uint256 startedAt,
      uint256 updatedAt,
      uint80 answeredInRound
    );

}

// SPDX-License-Identifier: None
pragma solidity 0.8.4;

interface IACOAssetConverterHelper {
    function setPairTolerancePercentage(address baseAsset, address quoteAsset, uint256 tolerancePercentage) external;
    function setAggregator(address baseAsset, address quoteAsset, address aggregator) external;
    function setUniswapMiddleRoute(address baseAsset, address quoteAsset, address[] calldata uniswapMiddleRoute) external;
    function withdrawStuckAsset(address asset, address destination) external;
    function hasAggregator(address baseAsset, address quoteAsset) external view returns(bool);
    function getPairData(address baseAsset, address quoteAsset) external view returns(address, uint256, uint256, uint256);
    function getUniswapMiddleRouteByIndex(address baseAsset, address quoteAsset, uint256 index) external view returns(address);
    function getPrice(address baseAsset, address quoteAsset) external view returns(uint256);
    function getPriceWithTolerance(address baseAsset, address quoteAsset, bool isMinimumPrice) external view returns(uint256);
    function getExpectedAmountOutToSwapExactAmountIn(address assetToSold, address assetToBuy, uint256 amountToBuy) external view returns(uint256);
    function getExpectedAmountOutToSwapExactAmountInWithSpecificTolerance(address assetToSold, address assetToBuy, uint256 amountToBuy, uint256 tolerancePercentage) external view returns(uint256);
    function swapExactAmountOut(address assetToSold, address assetToBuy, uint256 amountToSold) external payable returns(uint256);
    function swapExactAmountOutWithSpecificTolerance(address assetToSold, address assetToBuy, uint256 amountToSold, uint256 tolerancePercentage) external payable returns(uint256);
    function swapExactAmountOutWithMinAmountToReceive(address assetToSold, address assetToBuy, uint256 amountToSold, uint256 minAmountToReceive) external payable returns(uint256);
    function swapExactAmountIn(address assetToSold, address assetToBuy, uint256 amountToBuy) external payable returns(uint256);
    function swapExactAmountInWithSpecificTolerance(address assetToSold, address assetToBuy, uint256 amountToBuy, uint256 tolerancePercentage) external payable returns(uint256);
    function swapExactAmountInWithMaxAmountToSold(address assetToSold, address assetToBuy, uint256 amountToBuy, uint256 maxAmountToSold) external payable returns(uint256);
}

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

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

// SPDX-License-Identifier: None
pragma solidity 0.8.4;

interface IWETH {
    function deposit() external payable;
    function transfer(address to, uint value) external returns (bool);
    function withdraw(uint) external;
}

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

/*
 * @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 _msgSender() internal view virtual returns (address payable) {
        return payable(msg.sender);
    }

    function _msgData() 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;
    }
}

/**
 * @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.
 */
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.
     */
    function init() internal {
        require(_owner == address(0), "Ownable: Contract initialized");
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

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

// Contract on https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts
// SPDX-License-Identifier: MIT
pragma solidity 0.8.4;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[{"inputs":[{"internalType":"address","name":"_uniswapRouter","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"baseAsset","type":"address"},{"indexed":true,"internalType":"address","name":"quoteAsset","type":"address"},{"indexed":false,"internalType":"address","name":"previousAggregator","type":"address"},{"indexed":false,"internalType":"address","name":"newAggregator","type":"address"}],"name":"SetAggregator","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"baseAsset","type":"address"},{"indexed":true,"internalType":"address","name":"quoteAsset","type":"address"},{"indexed":false,"internalType":"uint256","name":"oldTolerancePercentage","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newTolerancePercentage","type":"uint256"}],"name":"SetPairTolerancePercentage","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"baseAsset","type":"address"},{"indexed":true,"internalType":"address","name":"quoteAsset","type":"address"},{"indexed":false,"internalType":"address[]","name":"previousUniswapMiddleRoute","type":"address[]"},{"indexed":false,"internalType":"address[]","name":"newUniswapMiddleRoute","type":"address[]"}],"name":"SetUniswapMiddleRoute","type":"event"},{"inputs":[],"name":"PERCENTAGE_PRECISION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"assetPrecision","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"assetToSold","type":"address"},{"internalType":"address","name":"assetToBuy","type":"address"},{"internalType":"uint256","name":"amountToBuy","type":"uint256"}],"name":"getExpectedAmountOutToSwapExactAmountIn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"assetToSold","type":"address"},{"internalType":"address","name":"assetToBuy","type":"address"},{"internalType":"uint256","name":"amountToBuy","type":"uint256"},{"internalType":"uint256","name":"tolerancePercentage","type":"uint256"}],"name":"getExpectedAmountOutToSwapExactAmountInWithSpecificTolerance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"baseAsset","type":"address"},{"internalType":"address","name":"quoteAsset","type":"address"}],"name":"getPairData","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"baseAsset","type":"address"},{"internalType":"address","name":"quoteAsset","type":"address"}],"name":"getPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"baseAsset","type":"address"},{"internalType":"address","name":"quoteAsset","type":"address"},{"internalType":"bool","name":"isMinimumPrice","type":"bool"}],"name":"getPriceWithTolerance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"baseAsset","type":"address"},{"internalType":"address","name":"quoteAsset","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getUniswapMiddleRouteByIndex","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"baseAsset","type":"address"},{"internalType":"address","name":"quoteAsset","type":"address"}],"name":"hasAggregator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"baseAsset","type":"address"},{"internalType":"address","name":"quoteAsset","type":"address"},{"internalType":"address","name":"aggregator","type":"address"}],"name":"setAggregator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"baseAsset","type":"address"},{"internalType":"address","name":"quoteAsset","type":"address"},{"internalType":"uint256","name":"tolerancePercentage","type":"uint256"}],"name":"setPairTolerancePercentage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"baseAsset","type":"address"},{"internalType":"address","name":"quoteAsset","type":"address"},{"internalType":"address[]","name":"uniswapMiddleRoute","type":"address[]"}],"name":"setUniswapMiddleRoute","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"assetToSold","type":"address"},{"internalType":"address","name":"assetToBuy","type":"address"},{"internalType":"uint256","name":"amountToBuy","type":"uint256"}],"name":"swapExactAmountIn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"assetToSold","type":"address"},{"internalType":"address","name":"assetToBuy","type":"address"},{"internalType":"uint256","name":"amountToBuy","type":"uint256"},{"internalType":"uint256","name":"maxAmountToSold","type":"uint256"}],"name":"swapExactAmountInWithMaxAmountToSold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"assetToSold","type":"address"},{"internalType":"address","name":"assetToBuy","type":"address"},{"internalType":"uint256","name":"amountToBuy","type":"uint256"},{"internalType":"uint256","name":"tolerancePercentage","type":"uint256"}],"name":"swapExactAmountInWithSpecificTolerance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"assetToSold","type":"address"},{"internalType":"address","name":"assetToBuy","type":"address"},{"internalType":"uint256","name":"amountToSold","type":"uint256"}],"name":"swapExactAmountOut","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"assetToSold","type":"address"},{"internalType":"address","name":"assetToBuy","type":"address"},{"internalType":"uint256","name":"amountToSold","type":"uint256"},{"internalType":"uint256","name":"minAmountToReceive","type":"uint256"}],"name":"swapExactAmountOutWithMinAmountToReceive","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"assetToSold","type":"address"},{"internalType":"address","name":"assetToBuy","type":"address"},{"internalType":"uint256","name":"amountToSold","type":"uint256"},{"internalType":"uint256","name":"tolerancePercentage","type":"uint256"}],"name":"swapExactAmountOutWithSpecificTolerance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapRouter","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"},{"internalType":"address","name":"destination","type":"address"}],"name":"withdrawStuckAsset","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0000000000000000000000001b02da8cb0d097eb8d57a175b88c7d8b47997506

-----Decoded View---------------
Arg [0] : _uniswapRouter (address): 0x1b02da8cb0d097eb8d57a175b88c7d8b47997506

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000001b02da8cb0d097eb8d57a175b88c7d8b47997506

310:20899:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1638:10;1652:9;1638:23;;1630:91;;;;-1:-1:-1;;;1630:91:0;;11879:2:9;1630:91:0;;;11861:21:9;11918:2;11898:18;;;11891:30;11957:34;11937:18;;;11930:62;12028:25;12008:18;;;12001:53;12071:19;;1630:91:0;;;;;;;;;310:20899;;;;;3599:1325;;;;;;;;;;-1:-1:-1;3599:1325:0;;;;;:::i;:::-;;:::i;5805:565::-;;;;;;;;;;-1:-1:-1;5805:565:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;6720:32:9;;;6702:51;;6690:2;6675:18;5805:565:0;;;;;;;;9477:511;;;;;;:::i;:::-;;:::i;:::-;;;18304:25:9;;;18292:2;18277:18;9477:511:0;18259:76:9;4932:291:0;;;;;;;;;;-1:-1:-1;4932:291:0;;;;;:::i;:::-;;:::i;7331:429::-;;;;;;;;;;-1:-1:-1;7331:429:0;;;;;:::i;:::-;;:::i;5469:328::-;;;;;;;;;;-1:-1:-1;5469:328:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;7981:32:9;;;7963:51;;8045:2;8030:18;;8023:34;;;;8073:18;;;8066:34;8131:2;8116:18;;8109:34;7950:3;7935:19;5469:328:0;7917:232:9;9996:452:0;;;;;;:::i;:::-;;:::i;2659:932::-;;;;;;;;;;-1:-1:-1;2659:932:0;;;;;:::i;:::-;;:::i;1170:49::-;;;;;;;;;;;;;;;2047:79:7;;;;;;;;;;-1:-1:-1;2085:7:7;2112:6;-1:-1:-1;;;;;2112:6:7;2047:79;;6598:333:0;;;;;;;;;;-1:-1:-1;6598:333:0;;;;;:::i;:::-;;:::i;1737:914::-;;;;;;;;;;-1:-1:-1;1737:914:0;;;;;:::i;:::-;;:::i;6378:212::-;;;;;;;;;;-1:-1:-1;6378:212:0;;;;;:::i;:::-;;:::i;5231:230::-;;;;;;;;;;-1:-1:-1;5231:230:0;;;;;:::i;:::-;;:::i;:::-;;;9658:14:9;;9651:22;9633:41;;9621:2;9606:18;5231:230:0;9588:92:9;1234:29:0;;;;;;;;;;;;;;;9124:345;;;;;;:::i;:::-;;:::i;7768:349::-;;;;;;:::i;:::-;;:::i;8125:515::-;;;;;;:::i;:::-;;:::i;8648:468::-;;;;;;:::i;:::-;;:::i;6939:384::-;;;;;;;;;;-1:-1:-1;6939:384:0;;;;;:::i;:::-;;:::i;454:53::-;;;;;;;;;;;;501:6;454:53;;2493:244:7;;;;;;;;;;-1:-1:-1;2493:244:7;;;;;:::i;:::-;;:::i;1345:49:0:-;;;;;;;;;;-1:-1:-1;1345:49:0;;;;;:::i;:::-;;;;;;;;;;;;;;3599:1325;2259:6:7;;-1:-1:-1;;;;;2259:6:7;698:10;2259:22;2251:67;;;;-1:-1:-1;;;2251:67:7;;;;;;;:::i;:::-;3743:70:0::1;3771:9;3782:10;3794:18;3743:27;:70::i;:::-;3825:13;3840:21:::0;3865:38:::1;3874:9;3885:10;3897:5;3865:8;:38::i;:::-;3918:16:::0;;3824:79;;-1:-1:-1;3824:79:0;-1:-1:-1;3918:16:0::1;;3914:1003;;;3955:8;3951:757;;;3984:22;4023:18;:25;4009:40;;;;;;-1:-1:-1::0;;;4009:40:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;-1:-1:-1;4009:40:0::1;-1:-1:-1::0;4121:25:0;;3984:65;;-1:-1:-1;4068:13:0::1;::::0;4104:167:::1;4148:5:::0;;4104:167:::1;;4198:18:::0;4217:3:::1;4219:1;4217::::0;:3:::1;:::i;:::-;4198:23;;;;;;-1:-1:-1::0;;;4198:23:0::1;;;;;;;;;;;;;;;4183:5;4189;4183:12;;;;;;-1:-1:-1::0;;;4183:12:0::1;;;;;;;;;-1:-1:-1::0;;;;;4183:38:0;;::::1;:12;::::0;;::::1;::::0;;;;;;;:38;4244:7:::1;::::0;::::1;:::i;:::-;::::0;-1:-1:-1;4155:3:0::1;::::0;::::1;:::i;:::-;;;4104:167;;;;4316:9;-1:-1:-1::0;;;;;4282:76:0::1;4304:10;-1:-1:-1::0;;;;;4282:76:0::1;;4327:4;:23;;4352:5;4282:76;;;;;;;:::i;:::-;;;;;;;;4377:30;4384:23;::::0;::::1;;4377:30;:::i;:::-;4426:31:::0;;::::1;::::0;:23:::1;::::0;::::1;::::0;:31:::1;::::0;::::1;::::0;::::1;:::i;:::-;;3951:757;;3914:1003;;3951:757;4524:10;-1:-1:-1::0;;;;;4491:89:0::1;4513:9;-1:-1:-1::0;;;;;4491:89:0::1;;4536:4;:23;;4561:18;4491:89;;;;;;;:::i;:::-;;;;;;;;4599:30;4606:23;::::0;::::1;;4599:30;:::i;:::-;4648:44:::0;;::::1;::::0;:23:::1;::::0;::::1;::::0;:44:::1;::::0;::::1;::::0;::::1;:::i;:::-;;3914:1003;;;4781:16;::::0;;4795:1:::1;4781:16:::0;;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;;;4736:82:0;;::::1;::::0;;;::::1;::::0;::::1;::::0;::::1;::::0;4781:16;4799:18;;4736:82:::1;:::i;:::-;;;;;;;;4833:72;4845:9;4856:10;4876:1;4880::::0;4883::::1;4886:18;4833:11;:72::i;:::-;2329:1:7;;3599:1325:0::0;;;:::o;5805:565::-;5926:7;5947:13;5962:20;5986:38;5995:9;6006:10;6018:5;5986:8;:38::i;:::-;5946:78;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;5946:78:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;5946:78:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6039:8;6035:328;;;6077:4;:23;;;:30;6068:5;:39;6064:218;;6143:1;6128:17;;;;;;6064:218;6193:23;;;;6218:30;;6259:1;;6218:38;;6251:5;;6218:38;:::i;:::-;:42;;;;:::i;:::-;6193:69;;;;;;-1:-1:-1;;;6193:69:0;;;;;;;;;;;;;;;6186:76;;;;;;6035:328;6321:4;:23;;;6345:5;6321:30;;;;;;-1:-1:-1;;;6321:30:0;;;;;;;;5805:565;;;;;;:::o;9477:511::-;9648:7;501:6;9676:19;:43;;9668:110;;;;-1:-1:-1;;;9668:110:0;;;;;;;:::i;:::-;9790:13;9805:21;9830:39;9839:11;9852:10;9864:4;9830:8;:39::i;:::-;9789:80;;;;9887:93;9906:11;9919:10;9931:11;9944:19;9965:8;9975:4;9887:18;:93::i;:::-;9880:100;9477:511;-1:-1:-1;;;;;;;9477:511:0:o;4932:291::-;2259:6:7;;-1:-1:-1;;;;;2259:6:7;698:10;2259:22;2251:67;;;;-1:-1:-1;;;2251:67:7;;;;;;;:::i;:::-;5033:14:0::1;5050:55;5084:5;5099:4;5050:33;:55::i;:::-;5033:72:::0;-1:-1:-1;5120:10:0;;5116:100:::1;;5147:57;5177:5;5184:11;5197:6;5147:29;:57::i;:::-;2329:1:7;4932:291:0::0;;:::o;7331:429::-;7521:7;7542:13;7557:21;7582:39;7591:11;7604:10;7616:4;7582:8;:39::i;:::-;7541:80;;;;7639:113;7678:11;7691:10;7703:11;7716:19;7737:8;7747:4;7639:38;:113::i;5469:328::-;5558:7;5567;5576;5585;5607:21;5632:38;5641:9;5652:10;5664:5;5632:8;:38::i;:::-;5689:15;;;5706:24;;;5732;;;;5758:23;;;;:30;5689:15;;;;-1:-1:-1;;;;;5689:15:0;;5706:24;;-1:-1:-1;5732:24:0;;-1:-1:-1;5758:30:0;-1:-1:-1;5469:328:0;-1:-1:-1;;;;;5469:328:0:o;9996:452::-;10161:7;10182:13;10197:21;10222:40;10231:11;10244:10;10256:5;10222:8;:40::i;:::-;10181:81;;;;10273:22;10283:11;10273:9;:22::i;:::-;10313:127;10351:11;10364:10;10376:11;10389:15;10406:8;10416:4;:23;;10313:37;:127::i;2659:932::-;2259:6:7;;-1:-1:-1;;;;;2259:6:7;698:10;2259:22;2251:67;;;;-1:-1:-1;;;2251:67:7;;;;;;;:::i;:::-;-1:-1:-1;;;;;2786:21:0;::::1;1156:20:2::0;2778:80:0::1;;;::::0;-1:-1:-1;;;2778:80:0;;11131:2:9;2778:80:0::1;::::0;::::1;11113:21:9::0;11170:2;11150:18;;;11143:30;-1:-1:-1;;;;;;;;;;;11189:18:9;;;11182:62;-1:-1:-1;;;11260:18:9;;;11253:42;11312:19;;2778:80:0::1;11103:234:9::0;2778:80:0::1;2869:27;2936:10;-1:-1:-1::0;;;;;2914:42:0::1;;:44;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2900:59;::::0;2906:53:::1;;2900:2;:59;:::i;:::-;2869:91;;2972:13;2987:21:::0;3012:38:::1;3021:9;3032:10;3044:5;3012:8;:38::i;:::-;3065:16:::0;;2971:79;;-1:-1:-1;2971:79:0;-1:-1:-1;3065:16:0::1;;3061:523;;;3093:8;3089:188;;;3152:15:::0;;3115:65:::1;::::0;;-1:-1:-1;;;;;3152:15:0::1;::::0;;::::1;::::0;::::1;6976:34:9::0;;7046:15;;;7041:2;7026:18;;7019:43;3115:65:0;;::::1;::::0;;::::1;::::0;::::1;::::0;6911:18:9;3115:65:0::1;;;;;;;3089:188;;;3242:15:::0;;3205:65:::1;::::0;;-1:-1:-1;;;;;3242:15:0::1;::::0;;::::1;::::0;::::1;6976:34:9::0;;7046:15;;;7041:2;7026:18;;7019:43;3205:65:0;;::::1;::::0;;::::1;::::0;::::1;::::0;6911:18:9;3205:65:0::1;;;;;;;3089:188;3291:28:::0;;-1:-1:-1;;;;;;3291:28:0::1;;-1:-1:-1::0;;;;;3291:28:0;::::1;;;::::0;;-1:-1:-1;3334:24:0;::::1;:46:::0;;;3061:523:::1;;;3409:60;::::0;;3454:1:::1;6976:34:9::0;;-1:-1:-1;;;;;7046:15:9;;;7041:2;7026:18;;7019:43;3409:60:0;;::::1;::::0;;;::::1;::::0;::::1;::::0;6911:18:9;3409:60:0::1;;;;;;;3484:88;3496:9:::0;3507:10;3519;3531:19;3552:1:::1;::::0;3555:16:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;-1:-1:-1;3555:16:0::1;;3484:11;:88::i;:::-;2329:1:7;;;2659:932:0::0;;;:::o;6598:333::-;6718:7;6739:13;6754:27;6785:54;6817:9;6828:10;6785:31;:54::i;:::-;6738:101;;;;6857:66;6880:5;6887:19;6908:14;6857:22;:66::i;:::-;6850:73;6598:333;-1:-1:-1;;;;;;6598:333:0:o;1737:914::-;2259:6:7;;-1:-1:-1;;;;;2259:6:7;698:10;2259:22;2251:67;;;;-1:-1:-1;;;2251:67:7;;;;;;;:::i;:::-;501:6:0::1;1886:19;:43;;1878:110;;;;-1:-1:-1::0;;;1878:110:0::1;;;;;;;:::i;:::-;2000:13;2015:21:::0;2040:38:::1;2049:9;2060:10;2072:5;2040:8;:38::i;:::-;2093:16:::0;;1999:79;;-1:-1:-1;1999:79:0;-1:-1:-1;2093:16:0::1;;2089:555;;;2121:8;2117:250;;;2182:9;-1:-1:-1::0;;;;;2143:96:0::1;2170:10;-1:-1:-1::0;;;;;2143:96:0::1;;2193:4;:24;;;2219:19;2143:96;;;;;;10102:25:9::0;;;10158:2;10143:18;;10136:34;10090:2;10075:18;;10057:119;2143:96:0::1;;;;;;;;2117:250;;;2302:10;-1:-1:-1::0;;;;;2264:96:0::1;2291:9;-1:-1:-1::0;;;;;2264:96:0::1;;2314:4;:24;;;2340:19;2264:96;;;;;;10102:25:9::0;;;10158:2;10143:18;;10136:34;10090:2;10075:18;;10057:119;2264:96:0::1;;;;;;;;2117:250;2381:24;::::0;::::1;:46:::0;;;2089:555:::1;;;2494:10;-1:-1:-1::0;;;;;2456:73:0::1;2483:9;-1:-1:-1::0;;;;;2456:73:0::1;;2506:1;2509:19;2456:73;;;;;;10102:25:9::0;;;10158:2;10143:18;;10136:34;10090:2;10075:18;;10057:119;2456:73:0::1;;;;;;;;2544:88;2556:9:::0;2567:10;2587:1:::1;::::0;2594:19;2587:1;2615:16:::1;::::0;6378:212;6464:7;6485:13;6503:54;6535:9;6546:10;6503:31;:54::i;:::-;-1:-1:-1;6484:73:0;-1:-1:-1;;6378:212:0;;;;;:::o;5231:230::-;5322:4;5341:21;5366:38;5375:9;5386:10;5398:5;5366:8;:38::i;:::-;5423:15;;;;-1:-1:-1;;;;;5423:15:0;:29;;;-1:-1:-1;;;5231:230:0;;;;:::o;9124:345::-;9245:7;9266:13;9281:21;9306:39;9315:11;9328:10;9340:4;9306:8;:39::i;:::-;9265:80;;;;9363:98;9382:11;9395:10;9407:11;9420:4;:24;;;9446:8;9456:4;9363:18;:98::i;7768:349::-;7891:7;7912:13;7927:21;7952:39;7961:11;7974:10;7986:4;7952:8;:39::i;:::-;7911:80;;;;8009:100;8029:11;8042:10;8054:12;8068:4;:24;;;8094:8;8104:4;8009:19;:100::i;8125:515::-;8298:7;501:6;8326:19;:43;;8318:110;;;;-1:-1:-1;;;8318:110:0;;;;;;;:::i;:::-;8440:13;8455:21;8480:39;8489:11;8502:10;8514:4;8480:8;:39::i;:::-;8439:80;;;;8537:95;8557:11;8570:10;8582:12;8596:19;8617:8;8627:4;8537:19;:95::i;8648:468::-;8821:7;8842:13;8857:21;8882:40;8891:11;8904:10;8916:5;8882:8;:40::i;:::-;8841:81;;;;8933:22;8943:11;8933:9;:22::i;:::-;8973:135;9015:11;9028:10;9040:12;9054:18;9074:8;9084:4;:23;;8973:41;:135::i;6939:384::-;7079:7;7100:13;7115:21;7140:39;7149:11;7162:10;7174:4;7140:8;:39::i;:::-;7099:80;;;;7197:118;7236:11;7249:10;7261:11;7274:4;:24;;;7300:8;7310:4;7197:38;:118::i;2493:244:7:-;2259:6;;-1:-1:-1;;;;;2259:6:7;698:10;2259:22;2251:67;;;;-1:-1:-1;;;2251:67:7;;;;;;;:::i;:::-;-1:-1:-1;;;;;2582:22:7;::::1;2574:73;;;::::0;-1:-1:-1;;;2574:73:7;;10724:2:9;2574:73:7::1;::::0;::::1;10706:21:9::0;10763:2;10743:18;;;10736:30;10802:34;10782:18;;;10775:62;-1:-1:-1;;;10853:18:9;;;10846:36;10899:19;;2574:73:7::1;10696:228:9::0;2574:73:7::1;2684:6;::::0;;2663:38:::1;::::0;-1:-1:-1;;;;;2663:38:7;;::::1;::::0;2684:6;::::1;::::0;2663:38:::1;::::0;::::1;2712:6;:17:::0;;-1:-1:-1;;;;;;2712:17:7::1;-1:-1:-1::0;;;;;2712:17:7;;;::::1;::::0;;;::::1;::::0;;2493:244::o;1729:237::-;1791:1;1773:6;-1:-1:-1;;;;;1773:6:7;:20;1765:62;;;;-1:-1:-1;;;1765:62:7;;16096:2:9;1765:62:7;;;16078:21:9;16135:2;16115:18;;;16108:30;16174:31;16154:18;;;16147:59;16223:18;;1765:62:7;16068:179:9;1765:62:7;1838:17;1881:18;;-1:-1:-1;;;;;;1881:18:7;698:10;1881:18;;;;;1915:43;;698:10;;;;1915:43;;1838:17;;1915:43;1729:237;:::o;14455:562:0:-;14591:9;14586:424;14610:18;:25;14606:1;:29;14586:424;;;14657:13;14673:18;14692:1;14673:21;;;;;;-1:-1:-1;;;14673:21:0;;;;;;;;;;;;;;;14657:37;;14727:5;-1:-1:-1;;;;;14717:15:0;:6;-1:-1:-1;;;;;14717:15:0;;;:34;;;;;14746:5;-1:-1:-1;;;;;14736:15:0;:6;-1:-1:-1;;;;;14736:15:0;;;14717:34;14709:93;;;;-1:-1:-1;;;14709:93:0;;;;;;;:::i;:::-;14822:9;14834:3;:1;14836;14834:3;:::i;:::-;14822:15;;14817:182;14843:18;:25;14839:1;:29;14817:182;;;14911:18;14930:1;14911:21;;;;;;-1:-1:-1;;;14911:21:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;14902:30:0;:5;-1:-1:-1;;;;;14902:30:0;;;14894:89;;;;-1:-1:-1;;;14894:89:0;;;;;;;:::i;:::-;14870:3;;;:::i;:::-;;;14817:182;;;;14586:424;14637:3;;;;:::i;:::-;;;14586:424;;;;14455:562;;;:::o;15441:636::-;-1:-1:-1;;;;;15613:16:0;;;15554:4;15613:16;;;:5;:16;;;;;;;;:28;;;;;;;;;;;15656:16;;15554:4;;15613:28;15656:16;;15652:418;;;15689:27;15688:28;:61;;;-1:-1:-1;15720:15:0;;;;;-1:-1:-1;;;;;15720:15:0;:29;;15688:61;15680:113;;;;-1:-1:-1;;;15680:113:0;;;;;;;:::i;:::-;15816:5;;-1:-1:-1;15823:4:0;-1:-1:-1;15808:20:0;;15652:418;-1:-1:-1;;;;;15877:17:0;;;15852:22;15877:17;;;:5;:17;;;;;;;;:28;;;;;;;;;15919;;;:62;;-1:-1:-1;15951:16:0;;;;;-1:-1:-1;;;;;15951:16:0;:30;;15919:62;15911:114;;;;-1:-1:-1;;;15911:114:0;;;;;;;:::i;:::-;16039:17;;;;;-1:-1:-1;16039:5:0;-1:-1:-1;16031:33:0;;-1:-1:-1;16031:33:0;15441:636;;;;;;;:::o;17182:796::-;17443:10;-1:-1:-1;;;;;17430:23:0;:9;-1:-1:-1;;;;;17430:23:0;;;17422:76;;;;-1:-1:-1;;;17422:76:0;;16862:2:9;17422:76:0;;;16844:21:9;16901:2;16881:18;;;16874:30;-1:-1:-1;;;;;;;;;;;16920:18:9;;;16913:62;-1:-1:-1;;;16991:18:9;;;16984:38;17039:19;;17422:76:0;16834:230:9;17422:76:0;-1:-1:-1;;;;;284:22:1;;;17517:60:0;;;-1:-1:-1;;;;;;17555:20:0;;1156::2;1204:8;;17555:22:0;17509:117;;;;-1:-1:-1;;;17509:117:0;;17608:2:9;17509:117:0;;;17590:21:9;17647:2;17627:18;;;17620:30;-1:-1:-1;;;;;;;;;;;17666:18:9;;;17659:62;-1:-1:-1;;;17737:18:9;;;17730:42;17789:19;;17509:117:0;17580:234:9;17509:117:0;-1:-1:-1;;;;;284:22:1;;;17645:62:0;;;-1:-1:-1;;;;;;17684:21:0;;1156:20:2;1204:8;;17684:23:0;17637:120;;;;-1:-1:-1;;;17637:120:0;;12726:2:9;17637:120:0;;;12708:21:9;12765:2;12745:18;;;12738:30;-1:-1:-1;;;;;;;;;;;12784:18:9;;;12777:62;-1:-1:-1;;;12855:18:9;;;12848:43;12908:19;;17637:120:0;12698:235:9;17637:120:0;17778:20;17788:9;17778;:20::i;:::-;17809:21;17819:10;17809:9;:21::i;:::-;17882:88;;;;;;;;17891:4;17882:88;;;-1:-1:-1;;;;;17882:88:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;17851:16;;;-1:-1:-1;17851:16:0;;;;;;;;;:28;;;;;;;;;;;:119;;;;;;-1:-1:-1;;;;;;17851:119:0;;;;;;-1:-1:-1;;;;;;17851:119:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17882:88;;17851:28;:119;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;;;;17182:796:0:o;10456:624::-;10689:7;10709:23;10735:197;10788:11;10814:10;10839:6;10860:19;10894:8;10917:4;10735:38;:197::i;:::-;10709:223;;10950:122;10988:11;11001:10;11013:6;11021:15;11038:8;11048:4;:23;;10950:37;:122::i;:::-;10943:129;10456:624;-1:-1:-1;;;;;;;;10456:624:0:o;2470:414:1:-;2552:7;-1:-1:-1;;;;;284:22:1;;2572:305;;-1:-1:-1;;;;;;2615:15:1;;;2608:22;;2572:305;2722:43;;;-1:-1:-1;;;;;6720:32:9;;;2722:43:1;;;;6702:51:9;;;;2722:43:1;;;;;;;;;;6675:18:9;;;;2722:43:1;;;;;;;-1:-1:-1;;;;;2722:43:1;-1:-1:-1;;;2722:43:1;;;2705:61;;2664:12;;;;2705:16;;;;:61;;2722:43;2705:61;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2663:103;;;;2789:7;2781:29;;;;-1:-1:-1;;;2781:29:1;;17271:2:9;2781:29:1;;;17253:21:9;17310:1;17290:18;;;17283:29;-1:-1:-1;;;17328:18:9;;;17321:39;17377:18;;2781:29:1;17243:158:9;2781:29:1;2843:10;2832:33;;;;;;;;;;;;:::i;:::-;2825:40;;;;;;3322:304;-1:-1:-1;;;;;284:22:1;;3409:210;;3485:12;;;3446;3485;;;;;;;;;-1:-1:-1;;;;;3463:7:1;;;3477:6;;3463:35;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3445:53;;;3521:7;3513:24;;;;-1:-1:-1;;;3513:24:1;;;;;;15764:2:9;15746:21;;;15803:1;15783:18;;;15776:29;-1:-1:-1;;;15836:2:9;15821:18;;15814:34;15880:2;15865:18;;15736:153;3409:210:1;3570:37;3589:5;3596:2;3600:6;3570:18;:37::i;11088:473:0:-;11346:7;11366:13;11382:103;11405:52;11430:10;11442:8;11452:4;11405:24;:52::i;:::-;11459:19;11480:4;11382:22;:103::i;:::-;-1:-1:-1;;;;;11514:27:0;;;;;;:14;:27;;;;;;11366:119;;-1:-1:-1;11503:50:0;;11366:119;;11503:39;;:6;;:10;:39::i;:::-;:43;;:50::i;17986:450::-;-1:-1:-1;;;;;18044:21:0;;;;;;:14;:21;;;;;;18040:389;;18087:16;18106:39;18139:5;18106:32;:39::i;:::-;18087:58;;;-1:-1:-1;18185:14:0;18087:58;18185:2;:14;:::i;:::-;-1:-1:-1;;;;;18160:21:0;;;;;;:14;:21;;;;;:40;;;;284:22:1;18215:203:0;;18271:131;18304:5;18319:13;-1:-1:-1;;18271:32:0;:131::i;:::-;18040:389;;17986:450;:::o;11569:1367::-;11837:7;11857:22;11882:61;11916:11;11937:4;11882:33;:61::i;:::-;11857:86;-1:-1:-1;;;;;;284:22:1;;11964:431:0;;12038:29;:14;12057:9;12038:18;:29::i;:::-;12021:46;;12103:15;12090:9;:28;;12082:85;;;;-1:-1:-1;;;12082:85:0;;15351:2:9;12082:85:0;;;15333:21:9;15390:2;15370:18;;;15363:30;-1:-1:-1;;;;;;;;;;;15409:18:9;;;15402:62;-1:-1:-1;;;15480:18:9;;;15473:42;15532:19;;12082:85:0;15323:234:9;12082:85:0;11964:431;;;12208:9;:14;12200:74;;;;-1:-1:-1;;;12200:74:0;;14238:2:9;12200:74:0;;;14220:21:9;14277:2;14257:18;;;14250:30;14316:34;14296:18;;;14289:62;-1:-1:-1;;;14367:18:9;;;14360:45;14422:19;;12200:74:0;14210:237:9;12200:74:0;12289:94;12327:11;12340:10;12360:4;12367:15;12289:37;:94::i;:::-;12407:109;12432:11;12445:10;12457:11;12470:15;12487:8;12497:18;12407:24;:109::i;:::-;12537:19;12559:61;12593:11;12614:4;12559:33;:61::i;:::-;12537:83;-1:-1:-1;12631:17:0;12651:31;12537:83;12667:14;12651:15;:31::i;:::-;12631:51;-1:-1:-1;12697:13:0;;12693:111;;12727:65;12757:11;12770:10;12782:9;12727:29;:65::i;:::-;12814:66;12844:10;12856;12868:11;12814:29;:66::i;:::-;12898:30;:15;12918:9;12898:19;:30::i;:::-;12891:37;11569:1367;-1:-1:-1;;;;;;;;;;11569:1367:0:o;16085:347::-;16187:7;16196;16217:13;16232:21;16257:37;16266:9;16277:10;16289:4;16257:8;:37::i;:::-;16216:78;;;;16305:13;16321:52;16346:10;16358:8;16368:4;16321:24;:52::i;:::-;16399:24;;;;;16305:68;;-1:-1:-1;16399:24:0;;-1:-1:-1;;;16085:347:0;;;;;:::o;15025:408::-;15144:7;15168:14;15164:262;;;15206:82;501:6;15206:56;15216:45;501:6;15241:19;15216:24;:45::i;:::-;15206:5;;:9;:56::i;:82::-;15199:89;;;;15164:262;15328:82;501:6;15328:56;15338:45;501:6;15363:19;15338:24;:45::i;12944:628::-;13178:7;13198:13;13214:103;13237:52;13262:10;13274:8;13284:4;13237:24;:52::i;13214:103::-;-1:-1:-1;;;;;13379:27:0;;13328:26;13379:27;;;:14;:27;;;;;;13198:119;;-1:-1:-1;13328:26:0;13357:50;;:17;13198:119;13367:6;13357:9;:17::i;:50::-;13328:79;;13435:129;13477:11;13490:10;13502:6;13510:18;13530:8;13540:4;:23;;13435:41;:129::i;:::-;13428:136;12944:628;-1:-1:-1;;;;;;;;;12944:628:0:o;13580:867::-;13856:7;13876:55;13905:11;13918:12;13876:28;:55::i;:::-;13952:22;13977:60;14011:10;14031:4;13977:33;:60::i;:::-;13952:85;;14058:114;14084:11;14097:10;14109:12;14123:18;14143:8;14153:18;14058:25;:114::i;:::-;14193:19;14215:60;14249:10;14269:4;14215:33;:60::i;:::-;14193:82;-1:-1:-1;14286:17:0;14306:31;14193:82;14322:14;14306:15;:31::i;:::-;14286:51;;14348:64;14378:10;14390;14402:9;14348:29;:64::i;638:314:1:-;789:53;;;-1:-1:-1;;;;;7645:32:9;;;789:53:1;;;7627:51:9;7694:18;;;;7687:34;;;789:53:1;;;;;;;;;;7600:18:9;;;;789:53:1;;;;;;;-1:-1:-1;;;;;789:53:1;-1:-1:-1;;;789:53:1;;;778:65;;-1:-1:-1;;;;778:10:1;;;;:65;;789:53;778:65;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;736:107;;;;862:7;:69;;;;-1:-1:-1;874:17:1;;:22;;:56;;;911:10;900:30;;;;;;;;;;;;:::i;:::-;854:90;;;;-1:-1:-1;;;854:90:1;;15015:2:9;854:90:1;;;14997:21:9;15054:1;15034:18;;;15027:29;-1:-1:-1;;;15072:18:9;;;15065:38;15120:18;;854:90:1;14987:157:9;16440:737:0;16554:7;16576:13;16618:4;:15;;;;;;;;;;-1:-1:-1;;;;;16618:15:0;-1:-1:-1;;;;;16596:54:0;;:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;16704:24:0;;;;-1:-1:-1;;;;;16765:26:0;;16673:28;16765:26;;;:14;:26;;;;;;16574:78;;-1:-1:-1;16704:24:0;-1:-1:-1;16812:358:0;;;;16848:62;16902:6;16848:41;:20;16873:15;16848:24;:41::i;:62::-;16841:69;;;;;;;16812:358;16955:15;16932:20;:38;16928:242;;;16994:62;17014:41;:20;17039:15;17014:24;:41::i;:::-;17002:6;;16994:19;:62::i;16928:242::-;17096:62;17137:20;17096:36;17104:6;17116:15;3591:98:8;3649:7;3676:5;3680:1;3676;:5;:::i;3990:98::-;4048:7;4075:5;4079:1;4075;:5;:::i;1700:376:1:-;1764:5;-1:-1:-1;;;;;284:22:1;;1782:287;;-1:-1:-1;1831:2:1;;1700:376;-1:-1:-1;1700:376:1:o;1782:287::-;1926:34;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1926:34:1;-1:-1:-1;;;1926:34:1;;;1909:52;;1868:12;;;;-1:-1:-1;;;;;1909:16:1;;;:52;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1867:94;;;;1984:7;1976:28;;;;-1:-1:-1;;;1976:28:1;;13140:2:9;1976:28:1;;;13122:21:9;13179:1;13159:18;;;13152:29;-1:-1:-1;;;13197:18:9;;;13190:38;13245:18;;1976:28:1;13112:157:9;1976:28:1;2037:10;2026:31;;;;;;;;;;;;:::i;:::-;2019:38;1700:376;-1:-1:-1;;;;1700:376:1:o;1782:287::-;1700:376;;;:::o;322:308::-;470:51;;;-1:-1:-1;;;;;7645:32:9;;;470:51:1;;;7627::9;7694:18;;;;7687:34;;;470:51:1;;;;;;;;;;7600:18:9;;;;470:51:1;;;;;;;-1:-1:-1;;;;;470:51:1;-1:-1:-1;;;470:51:1;;;459:63;;-1:-1:-1;;;;459:10:1;;;;:63;;470:51;459:63;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;417:105;;;;541:7;:69;;;;-1:-1:-1;553:17:1;;:22;;:56;;;590:10;579:30;;;;;;;;;;;;:::i;:::-;533:89;;;;-1:-1:-1;;;533:89:1;;11544:2:9;533:89:1;;;11526:21:9;11583:1;11563:18;;;11556:29;-1:-1:-1;;;11601:18:9;;;11594:37;11648:18;;533:89:1;11516:156:9;3234:98:8;3292:7;3319:5;3323:1;3319;:5;:::i;961:346:1:-;1132:61;;;-1:-1:-1;;;;;7331:15:9;;;1132:61:1;;;7313:34:9;7383:15;;;7363:18;;;7356:43;7415:18;;;;7408:34;;;1132:61:1;;;;;;;;;;7248:18:9;;;;1132:61:1;;;;;;;-1:-1:-1;;;;;1132:61:1;-1:-1:-1;;;1132:61:1;;;1121:73;;-1:-1:-1;;;;1121:10:1;;;;:73;;1132:61;1121:73;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1079:115;;;;1213:7;:69;;;;-1:-1:-1;1225:17:1;;:22;;:56;;;1262:10;1251:30;;;;;;;;;;;;:::i;:::-;1205:94;;;;-1:-1:-1;;;1205:94:1;;10383:2:9;1205:94:1;;;10365:21:9;10422:2;10402:18;;;10395:30;-1:-1:-1;;;10441:18:9;;;10434:42;10493:18;;1205:94:1;10355:162:9;20376:830:0;20623:21;20647:70;20669:8;20679:7;20688:8;20698:18;20647:21;:70::i;:::-;20623:94;-1:-1:-1;;;;;;284:22:1;;20728:471:0;;20782:104;;-1:-1:-1;;;20782:104:0;;-1:-1:-1;;;;;20782:13:0;:35;;;;20825:12;;20782:104;;20839:8;;20849:4;;20863;;20870:15;;20782:104;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;20782:104:0;;;;;;;;;;;;:::i;:::-;;20728:471;;;-1:-1:-1;;;;;284:22:1;;20904:295:0;;20957:97;;-1:-1:-1;;;20957:97:0;;-1:-1:-1;;;;;20957:13:0;:35;;;;:97;;20993:8;;21003:12;;21017:4;;21031;;21038:15;;20957:97;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;20957:97:0;;;;;;;;;;;;:::i;20904:295::-;21087:100;;-1:-1:-1;;;21087:100:0;;-1:-1:-1;;;;;21087:13:0;:38;;;;:100;;21126:8;;21136:12;;21150:4;;21164;;21171:15;;21087:100;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;21087:100:0;;;;;;;;;;;;:::i;:::-;;20904:295;20376:830;;;;;;;:::o;2853:98:8:-;2911:7;2938:5;2942:1;2938;:5;:::i;3634:328:1:-;-1:-1:-1;;;;;284:22:1;;3708:247;;3765:6;3752:9;:19;3744:50;;;;-1:-1:-1;;;3744:50:1;;13476:2:9;3744:50:1;;;13458:21:9;13515:2;13495:18;;;13488:30;-1:-1:-1;;;13534:18:9;;;13527:48;13592:18;;3744:50:1;13448:168:9;3744:50:1;3708:247;;;3835:9;:14;3827:37;;;;-1:-1:-1;;;3827:37:1;;18021:2:9;3827:37:1;;;18003:21:9;18060:2;18040:18;;;18033:30;-1:-1:-1;;;18079:18:9;;;18072:40;18129:18;;3827:37:1;17993:160:9;3827:37:1;3879:64;3902:5;3909:10;3929:4;3936:6;3879:22;:64::i;19538:830:0:-;19785:21;19809:70;19831:8;19841:7;19850:8;19860:18;19809:21;:70::i;:::-;19785:94;-1:-1:-1;;;;;;284:22:1;;19890:471:0;;19944:104;;-1:-1:-1;;;19944:104:0;;-1:-1:-1;;;;;19944:13:0;:35;;;;19987:9;;19944:104;;19998:11;;20011:4;;20025;;20032:15;;19944:104;;;:::i;19890:471::-;-1:-1:-1;;;;;284:22:1;;20066:295:0;;20119:97;;-1:-1:-1;;;20119:97:0;;-1:-1:-1;;;;;20119:13:0;:35;;;;:97;;20155:9;;20166:11;;20179:4;;20193;;20200:15;;20119:97;;;:::i;20066:295::-;20249:100;;-1:-1:-1;;;20249:100:0;;-1:-1:-1;;;;;20249:13:0;:38;;;;:100;;20288:9;;20299:11;;20312:4;;20326;;20333:15;;20249:100;;;:::i;18441:1088::-;18653:25;;18582:16;;18611:21;;18649:29;;:1;:29;:::i;:::-;18635:44;;;;;;-1:-1:-1;;;18635:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18635:44:0;-1:-1:-1;18611:68:0;-1:-1:-1;18690:11:0;-1:-1:-1;;;;;284:22:1;;18712:301:0;;18776:4;18766;18771:1;18766:7;;;;;;-1:-1:-1;;;18766:7:0;;;;;;;;;-1:-1:-1;;;;;18766:14:0;;;:7;;;;;;;;;;;:14;-1:-1:-1;18801:7:0;18712:301;;;-1:-1:-1;;;;;284:22:1;;18826:187:0;;18889:8;18879:4;18884:1;18879:7;;;;;;-1:-1:-1;;;18879:7:0;;;;;;;;;-1:-1:-1;;;;;18879:18:0;;;:7;;;;;;;;;;;:18;-1:-1:-1;18918:4:0;18826:187;;;18965:8;18955:4;18960:1;18955:7;;;;;;-1:-1:-1;;;18955:7:0;;;;;;;;;-1:-1:-1;;;;;18955:18:0;;;:7;;;;;;;;;;;:18;-1:-1:-1;18994:7:0;18826:187;19064:25;;19039:1;;19023:13;;19064:29;;;;:41;;;19097:8;19064:41;:79;;19142:1;19064:79;;;19109:25;;:29;;19137:1;;19109:29;:::i;:::-;19051:93;;19155:320;19166:25;;19162:29;;:39;;;;-1:-1:-1;19195:6:0;19162:39;19155:320;;;19232:18;19251:1;19232:21;;;;;;-1:-1:-1;;;19232:21:0;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19232:21:0;19218:4;19223:5;19218:11;;;;;;-1:-1:-1;;;19218:11:0;;;;;;;;;-1:-1:-1;;;;;19218:35:0;;;:11;;;;;;;;;;;:35;19268:7;;;:::i;:::-;;;19294:8;19290:174;;;19327:6;19323:60;;19358:5;;19323:60;19401:3;;;:::i;:::-;;;19155:320;;19290:174;19445:3;;;:::i;19155:320::-;19499:3;19485:4;19490:5;19485:11;;;;;;-1:-1:-1;;;19485:11:0;;;;;;;;;-1:-1:-1;;;;;19485:17:0;;;:11;;;;;;;;;;;:17;-1:-1:-1;19520:4:0;;-1:-1:-1;;;18441:1088:0;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:173:9;82:20;;-1:-1:-1;;;;;131:31:9;;121:42;;111:2;;177:1;174;167:12;192:179;270:13;;323:22;312:34;;302:45;;292:2;;361:1;358;351:12;376:196;435:6;488:2;476:9;467:7;463:23;459:32;456:2;;;509:6;501;494:22;456:2;537:29;556:9;537:29;:::i;577:270::-;645:6;653;706:2;694:9;685:7;681:23;677:32;674:2;;;727:6;719;712:22;674:2;755:29;774:9;755:29;:::i;:::-;745:39;;803:38;837:2;826:9;822:18;803:38;:::i;:::-;793:48;;664:183;;;;;:::o;852:344::-;929:6;937;945;998:2;986:9;977:7;973:23;969:32;966:2;;;1019:6;1011;1004:22;966:2;1047:29;1066:9;1047:29;:::i;:::-;1037:39;;1095:38;1129:2;1118:9;1114:18;1095:38;:::i;:::-;1085:48;;1152:38;1186:2;1175:9;1171:18;1152:38;:::i;:::-;1142:48;;956:240;;;;;:::o;1201:1101::-;1303:6;1311;1319;1372:2;1360:9;1351:7;1347:23;1343:32;1340:2;;;1393:6;1385;1378:22;1340:2;1421:29;1440:9;1421:29;:::i;:::-;1411:39;;1469:2;1490:38;1524:2;1513:9;1509:18;1490:38;:::i;:::-;1480:48;;1579:2;1568:9;1564:18;1551:32;1606:18;1598:6;1595:30;1592:2;;;1643:6;1635;1628:22;1592:2;1671:22;;1724:4;1716:13;;1712:27;-1:-1:-1;1702:2:9;;1758:6;1750;1743:22;1702:2;1799;1786:16;1822:60;1838:43;1878:2;1838:43;:::i;:::-;1822:60;:::i;:::-;1904:3;1928:2;1923:3;1916:15;1956:2;1951:3;1947:12;1940:19;;1987:2;1983;1979:11;2035:7;2030:2;2024;2021:1;2017:10;2013:2;2009:19;2005:28;2002:41;1999:2;;;2061:6;2053;2046:22;1999:2;2088:6;2079:15;;2103:169;2117:2;2114:1;2111:9;2103:169;;;2174:23;2193:3;2174:23;:::i;:::-;2162:36;;2135:1;2128:9;;;;;2218:12;;;;2250;;2103:169;;;2107:3;2291:5;2281:15;;;;;;;1330:972;;;;;:::o;2307:399::-;2381:6;2389;2397;2450:2;2438:9;2429:7;2425:23;2421:32;2418:2;;;2471:6;2463;2456:22;2418:2;2499:29;2518:9;2499:29;:::i;:::-;2489:39;;2547:38;2581:2;2570:9;2566:18;2547:38;:::i;:::-;2537:48;;2635:2;2624:9;2620:18;2607:32;2648:28;2670:5;2648:28;:::i;:::-;2695:5;2685:15;;;2408:298;;;;;:::o;2711:338::-;2788:6;2796;2804;2857:2;2845:9;2836:7;2832:23;2828:32;2825:2;;;2878:6;2870;2863:22;2825:2;2906:29;2925:9;2906:29;:::i;:::-;2896:39;;2954:38;2988:2;2977:9;2973:18;2954:38;:::i;:::-;2944:48;;3039:2;3028:9;3024:18;3011:32;3001:42;;2815:234;;;;;:::o;3054:407::-;3140:6;3148;3156;3164;3217:3;3205:9;3196:7;3192:23;3188:33;3185:2;;;3239:6;3231;3224:22;3185:2;3267:29;3286:9;3267:29;:::i;:::-;3257:39;;3315:38;3349:2;3338:9;3334:18;3315:38;:::i;:::-;3175:286;;3305:48;;-1:-1:-1;;;;3400:2:9;3385:18;;3372:32;;3451:2;3436:18;3423:32;;3175:286::o;3466:937::-;3561:6;3592:2;3635;3623:9;3614:7;3610:23;3606:32;3603:2;;;3656:6;3648;3641:22;3603:2;3694:9;3688:16;3727:18;3719:6;3716:30;3713:2;;;3764:6;3756;3749:22;3713:2;3792:22;;3845:4;3837:13;;3833:27;-1:-1:-1;3823:2:9;;3879:6;3871;3864:22;3823:2;3913;3907:9;3936:60;3952:43;3992:2;3952:43;:::i;3936:60::-;4018:3;4042:2;4037:3;4030:15;4070:2;4065:3;4061:12;4054:19;;4101:2;4097;4093:11;4149:7;4144:2;4138;4135:1;4131:10;4127:2;4123:19;4119:28;4116:41;4113:2;;;4175:6;4167;4160:22;4113:2;4202:6;4193:15;;4217:156;4231:2;4228:1;4225:9;4217:156;;;4288:10;;4276:23;;4249:1;4242:9;;;;;4319:12;;;;4351;;4217:156;;;-1:-1:-1;4392:5:9;3572:831;-1:-1:-1;;;;;;;3572:831:9:o;4408:255::-;4475:6;4528:2;4516:9;4507:7;4503:23;4499:32;4496:2;;;4549:6;4541;4534:22;4496:2;4586:9;4580:16;4605:28;4627:5;4605:28;:::i;4668:194::-;4738:6;4791:2;4779:9;4770:7;4766:23;4762:32;4759:2;;;4812:6;4804;4797:22;4759:2;-1:-1:-1;4840:16:9;;4749:113;-1:-1:-1;4749:113:9:o;4867:483::-;4970:6;4978;4986;4994;5002;5055:3;5043:9;5034:7;5030:23;5026:33;5023:2;;;5077:6;5069;5062:22;5023:2;5105:39;5134:9;5105:39;:::i;:::-;5095:49;;5184:2;5173:9;5169:18;5163:25;5153:35;;5228:2;5217:9;5213:18;5207:25;5197:35;;5272:2;5261:9;5257:18;5251:25;5241:35;;5295:49;5339:3;5328:9;5324:19;5295:49;:::i;:::-;5285:59;;5013:337;;;;;;;;:::o;5355:293::-;5423:6;5476:2;5464:9;5455:7;5451:23;5447:32;5444:2;;;5497:6;5489;5482:22;5444:2;5534:9;5528:16;5584:4;5577:5;5573:16;5566:5;5563:27;5553:2;;5609:6;5601;5594:22;5653:463;5706:3;5744:5;5738:12;5771:6;5766:3;5759:19;5797:4;5826:2;5821:3;5817:12;5810:19;;5863:2;5856:5;5852:14;5884:3;5896:195;5910:6;5907:1;5904:13;5896:195;;;5975:13;;-1:-1:-1;;;;;5971:39:9;5959:52;;6031:12;;;;6066:15;;;;6007:1;5925:9;5896:195;;;-1:-1:-1;6107:3:9;;5714:402;-1:-1:-1;;;;;5714:402:9:o;6121:430::-;6250:3;6288:6;6282:13;6313:3;6325:129;6339:6;6336:1;6333:13;6325:129;;;6437:4;6421:14;;;6417:25;;6411:32;6398:11;;;6391:53;6354:12;6325:129;;;6472:6;6469:1;6466:13;6463:2;;;6507:3;6498:6;6493:3;6489:16;6482:29;6463:2;-1:-1:-1;6529:16:9;;;;;6258:293;-1:-1:-1;;6258:293:9:o;8154:465::-;8411:2;8400:9;8393:21;8374:4;8437:56;8489:2;8478:9;8474:18;8466:6;8437:56;:::i;:::-;8541:9;8533:6;8529:22;8524:2;8513:9;8509:18;8502:50;8569:44;8606:6;8598;8569:44;:::i;:::-;8561:52;8383:236;-1:-1:-1;;;;;8383:236:9:o;8624:864::-;8841:4;8889:2;8878:9;8874:18;8919:2;8908:9;8901:21;8942:6;8977;8971:13;9008:6;9000;8993:22;9046:2;9035:9;9031:18;9024:25;;9071:6;9065:4;9058:20;9097:4;9087:14;;9140:2;9134:4;9124:19;9161:4;9174:194;9188:6;9185:1;9182:13;9174:194;;;9253:13;;-1:-1:-1;;;;;9249:39:9;9237:52;;9309:12;;;;9285:1;9344:14;;;;9203:9;9174:194;;;9178:3;;;9413:9;9408:3;9404:19;9399:2;9388:9;9384:18;9377:47;9441:41;9478:3;9470:6;9441:41;:::i;12101:418::-;12303:2;12285:21;;;12342:2;12322:18;;;12315:30;-1:-1:-1;;;;;;;;;;;12376:2:9;12361:18;;12354:62;-1:-1:-1;;;12447:2:9;12432:18;;12425:52;12509:3;12494:19;;12275:244::o;13621:410::-;13823:2;13805:21;;;13862:2;13842:18;;;13835:30;-1:-1:-1;;;;;;;;;;;13896:2:9;13881:18;;13874:62;-1:-1:-1;;;13967:2:9;13952:18;;13945:44;14021:3;14006:19;;13795:236::o;14452:356::-;14654:2;14636:21;;;14673:18;;;14666:30;14732:34;14727:2;14712:18;;14705:62;14799:2;14784:18;;14626:182::o;16252:403::-;16454:2;16436:21;;;16493:2;16473:18;;;16466:30;16532:34;16527:2;16512:18;;16505:62;-1:-1:-1;;;16598:2:9;16583:18;;16576:37;16645:3;16630:19;;16426:229::o;18340:502::-;18603:6;18592:9;18585:25;18646:3;18641:2;18630:9;18626:18;18619:31;18566:4;18667:57;18719:3;18708:9;18704:19;18696:6;18667:57;:::i;:::-;-1:-1:-1;;;;;18760:32:9;;;;18755:2;18740:18;;18733:60;-1:-1:-1;18824:2:9;18809:18;18802:34;18659:65;18575:267;-1:-1:-1;;18575:267:9:o;19100:574::-;19391:6;19380:9;19373:25;19434:6;19429:2;19418:9;19414:18;19407:34;19477:3;19472:2;19461:9;19457:18;19450:31;19354:4;19498:57;19550:3;19539:9;19535:19;19527:6;19498:57;:::i;:::-;-1:-1:-1;;;;;19591:32:9;;;;19586:2;19571:18;;19564:60;-1:-1:-1;19655:3:9;19640:19;19633:35;19490:65;19363:311;-1:-1:-1;;;19363:311:9:o;19679:275::-;19750:2;19744:9;19815:2;19796:13;;-1:-1:-1;;19792:27:9;19780:40;;19850:18;19835:34;;19871:22;;;19832:62;19829:2;;;19897:18;;:::i;:::-;19933:2;19926:22;19724:230;;-1:-1:-1;19724:230:9:o;19959:183::-;20019:4;20052:18;20044:6;20041:30;20038:2;;;20074:18;;:::i;:::-;-1:-1:-1;20119:1:9;20115:14;20131:4;20111:25;;20028:114::o;20147:128::-;20187:3;20218:1;20214:6;20211:1;20208:13;20205:2;;;20224:18;;:::i;:::-;-1:-1:-1;20260:9:9;;20195:80::o;20280:217::-;20320:1;20346;20336:2;;-1:-1:-1;;;20371:31:9;;20425:4;20422:1;20415:15;20453:4;20378:1;20443:15;20336:2;-1:-1:-1;20482:9:9;;20326:171::o;20502:422::-;20591:1;20634:5;20591:1;20648:270;20669:7;20659:8;20656:21;20648:270;;;20728:4;20724:1;20720:6;20716:17;20710:4;20707:27;20704:2;;;20737:18;;:::i;:::-;20787:7;20777:8;20773:22;20770:2;;;20807:16;;;;20770:2;20886:22;;;;20846:15;;;;20648:270;;;20652:3;20566:358;;;;;:::o;20929:131::-;20989:5;21018:36;21045:8;21039:4;21114:5;21144:8;21134:2;;-1:-1:-1;21185:1:9;21199:5;;21134:2;21233:4;21223:2;;-1:-1:-1;21270:1:9;21284:5;;21223:2;21315:4;21333:1;21328:59;;;;21401:1;21396:130;;;;21308:218;;21328:59;21358:1;21349:10;;21372:5;;;21396:130;21433:3;21423:8;21420:17;21417:2;;;21440:18;;:::i;:::-;-1:-1:-1;;21496:1:9;21482:16;;21511:5;;21308:218;;21610:2;21600:8;21597:16;21591:3;21585:4;21582:13;21578:36;21572:2;21562:8;21559:16;21554:2;21548:4;21545:12;21541:35;21538:77;21535:2;;;-1:-1:-1;21647:19:9;;;21679:5;;21535:2;21726:34;21751:8;21745:4;21726:34;:::i;:::-;21796:6;21792:1;21788:6;21784:19;21775:7;21772:32;21769:2;;;21807:18;;:::i;:::-;21845:20;;21124:747;-1:-1:-1;;;21124:747:9:o;21876:168::-;21916:7;21982:1;21978;21974:6;21970:14;21967:1;21964:21;21959:1;21952:9;21945:17;21941:45;21938:2;;;21989:18;;:::i;:::-;-1:-1:-1;22029:9:9;;21928:116::o;22049:125::-;22089:4;22117:1;22114;22111:8;22108:2;;;22122:18;;:::i;:::-;-1:-1:-1;22159:9:9;;22098:76::o;22179:136::-;22218:3;22246:5;22236:2;;22255:18;;:::i;:::-;-1:-1:-1;;;22291:18:9;;22226:89::o;22320:135::-;22359:3;-1:-1:-1;;22380:17:9;;22377:2;;;22400:18;;:::i;:::-;-1:-1:-1;22447:1:9;22436:13;;22367:88::o;22460:127::-;22521:10;22516:3;22512:20;22509:1;22502:31;22552:4;22549:1;22542:15;22576:4;22573:1;22566:15;22592:127;22653:10;22648:3;22644:20;22641:1;22634:31;22684:4;22681:1;22674:15;22708:4;22705:1;22698:15;22724:118;22810:5;22803:13;22796:21;22789:5;22786:32;22776:2;;22832:1;22829;22822:12

dffd51fe4c287991962a1e68f90709ab4c0b8857519c9d1acb21fc7a21c8f805