pragma solidity =0.6.6;


interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

interface IERC20 {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
}

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

library TransferHelper {
    function safeApprove(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
    }

    function safeTransfer(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
    }

    function safeTransferFrom(address token, address from, address to, uint value) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
    }

    function safeTransferETH(address to, uint value) internal {
        (bool success,) = to.call{value:value}(new bytes(0));
        require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
    }
}


library SafeMath {
    function add(uint x, uint y) internal pure returns (uint z) {
        require((z = x + y) >= x, 'ds-math-add-overflow');
    }

    function sub(uint x, uint y) internal pure returns (uint z) {
        require((z = x - y) <= x, 'ds-math-sub-underflow');
    }

    function mul(uint x, uint y) internal pure returns (uint z) {
        require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
    }
}

contract MyRouter {
    uint256 private constant CHISTART_MASK =  0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00;
    uint256 private constant ISUNISWAP_MASK = 0x000000000000000000000000000000000000000000000000000000000000000f;
    
    using SafeMath for uint;
    
    modifier onlyTrader {
        require((msg.sender == 0x19aBe4496214Df53bd60BF05385c2bc28e87A090) || (msg.sender == 0x1Afa018d9Be65B0Eac856340d919c4526C168FF8) || (msg.sender == 0xd05aE1dA4f202d82F165F6b0291E6bE4668B39B8) || (msg.sender == 0x44A5d8240174F7164FF963D9062CdF1148410459), "not trader");
        _;
    }
    

    constructor() public{
    }
    
    function withdrawETH() public onlyTrader{
        msg.sender.transfer(address(this).balance);
    }
    
    function withdrawToken(address tokenAddress, uint amount) public onlyTrader{
        TransferHelper.safeTransfer(tokenAddress, msg.sender, amount);
    }
    
    function withdrawTokens(address[] memory path) public onlyTrader{
        for (uint i; i < path.length; i++) {
            IERC20 token = IERC20(path[i]);
            uint256 currentTokenBalance = token.balanceOf(address(this));
            TransferHelper.safeTransfer(path[i], msg.sender, currentTokenBalance);
        }
    }

    function swap25927504(
        uint amount,
        uint tokenMax,
        uint amountMin,
        address tokenA,
        address tokenB,
        uint data
    ) public onlyTrader {
        uint256 gasStart = gasleft();
        uint256 chiStart = (data & CHISTART_MASK) >> 8;
        uint256 isUniswap = data & ISUNISWAP_MASK;
        address pairOwner;
        if (isUniswap==1) {
            pairOwner = pairFor_sushi(tokenA, tokenB);
        } else {
            pairOwner = pairFor_uni(tokenA, tokenB);
        }
        (uint reserveA, uint reserveB) = getReserves(tokenA, tokenB, pairOwner);
        if (tokenMax > amountMin + reserveA) {
            if (tokenMax - reserveA>amount) {
                swapExactTokensForTokens(
                    amount,
                    tokenA,
                    tokenB,
                    reserveA,
                    reserveB,
                    pairOwner
                );
            } else {
                swapExactTokensForTokens(
                    tokenMax - reserveA,
                    tokenA,
                    tokenB,
                    reserveA,
                    reserveB,
                    pairOwner
                );
            }
        }
        if (chiStart>0) {
            uint256 gasSpent = 21000 + gasStart - gasleft() + 16 * msg.data.length;
            free( (gasSpent + 14154) / 41130, chiStart);
        }
        
    }
    
    function swap26309536(
        address tokenA,
        address tokenB,
        uint amountIn,
        uint amountOut,
        uint data
    ) public onlyTrader{
        uint256 gasStart = gasleft();
        uint256 chiStart = (data & CHISTART_MASK) >> 8;
        uint256 isUniswap = data & ISUNISWAP_MASK;
        address pairOwner;
        if (isUniswap==1) {
            pairOwner = pairFor_sushi(tokenA, tokenB);
        } else {
            pairOwner = pairFor_uni(tokenA, tokenB);
        }
        TransferHelper.safeTransfer(
            tokenA, pairOwner, amountIn
            );
        _swap(amountOut, tokenA, tokenB, pairOwner);
        if (chiStart>0) {
            uint256 gasSpent = 21000 + gasStart - gasleft() + 16 * msg.data.length;
            free( (gasSpent + 14154) / 41130, chiStart);
        }
    }
    
    function swapBackAll23252139(
        uint token0Max,
        address tokenA,
        address tokenB,
        bool isUniswap
    ) public onlyTrader {
        IERC20 tokenERC20 = IERC20(tokenA);
        uint myToken = tokenERC20.balanceOf(address(this));
        require(myToken>0);
        address pairOwner;
        if (isUniswap) {
            pairOwner = pairFor_sushi(tokenA, tokenB);
        } else {
            pairOwner = pairFor_uni(tokenA, tokenB);
        }
        (uint reserveA, uint reserveB) = getReserves(tokenA, tokenB, pairOwner);
        require(reserveA<=token0Max);
        swapExactTokensForTokens(
                myToken-1,
                tokenA,
                tokenB,
                reserveA,
                reserveB,
                pairOwner
            );
    }
    
    function swapBackAllFee19870645(
        uint token0Max,
        address tokenA,
        address tokenB,
        bool isUniswap
    ) public onlyTrader {
        IERC20 tokenERC20 = IERC20(tokenA);
        uint myToken = tokenERC20.balanceOf(address(this));
        require(myToken>0);
        address pairOwner;
        if (isUniswap) {
            pairOwner = pairFor_sushi(tokenA, tokenB);
        } else {
            pairOwner = pairFor_uni(tokenA, tokenB);
        }
        (uint reserveA, uint reserveB) = getReserves(tokenA, tokenB, pairOwner);
        require(reserveA<=token0Max);
        TransferHelper.safeTransfer(
            tokenA, pairOwner, myToken-1
            );
        myToken = tokenERC20.balanceOf(pairOwner) - reserveA;
        uint amountOut = getAmountOut(myToken, reserveA, reserveB);
        _swap(amountOut, tokenA, tokenB, pairOwner);
        
        
    }
    
    
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
        require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT');
        require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
        uint amountInWithFee = amountIn.mul(997);
        uint numerator = amountInWithFee.mul(reserveOut);
        uint denominator = reserveIn.mul(1000).add(amountInWithFee);
        amountOut = numerator / denominator;
    }

    // given an output amount of an asset and pair reserves, returns a required input amount of the other asset
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
        require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT');
        require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
        uint numerator = reserveIn.mul(amountOut).mul(1000);
        uint denominator = reserveOut.sub(amountOut).mul(997);
        amountIn = (numerator / denominator).add(1);
    }
    
    // **** SWAP ****
    // requires the initial amount to have already been sent to the first pair
    function _swap(uint amountOut, address tokenA, address tokenB, address pairOwner) internal virtual {
        (address token0,) = sortTokens(tokenA, tokenB);
        (uint amount0Out, uint amount1Out) = tokenA == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
        IUniswapV2Pair(pairOwner).swap(
            amount0Out, amount1Out, address(this), new bytes(0)
        );
    }
    
    function swapExactTokensForTokens(
        uint amountIn,
        address tokenA,
        address tokenB,
        uint reserveA,
        uint reserveB,
        address pairOwner
    ) internal virtual returns (uint amountOut) {
        amountOut = getAmountOut(amountIn, reserveA, reserveB);
        TransferHelper.safeTransfer(
            tokenA, pairOwner, amountIn
            );
        _swap(amountOut, tokenA, tokenB, pairOwner);
    }
    

    function getReserves(address tokenA, address tokenB, address pairOwner) internal view returns (uint reserveA, uint reserveB) {
        (address token0,) = sortTokens(tokenA, tokenB);
        (uint reserve0, uint reserve1,) = IUniswapV2Pair(pairOwner).getReserves();
        (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
    }
    
    function pairFor_uni(address tokenA, address tokenB) internal pure returns (address pair) {
        (address token0, address token1) = sortTokens(tokenA, tokenB);
        pair = address(uint(keccak256(abi.encodePacked(
                hex'ff',
                0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
                keccak256(abi.encodePacked(token0, token1)),
                hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' // init code hash
            ))));
    }
    
    function pairFor_sushi(address tokenA, address tokenB) internal pure returns (address pair) {
        (address token0, address token1) = sortTokens(tokenA, tokenB);
        pair = address(uint(keccak256(abi.encodePacked(
                hex'ff',
                0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac,
                keccak256(abi.encodePacked(token0, token1)),
                hex'e18a34eb0e04b04f7a0ac29a6e80748dca96319b42c54d679cb821dca90c6303' // init code hash
            ))));
    }
    
    function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
        require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
        (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
        require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');
    }
    
    function checkFees(
                address tokenA,
                address tokenB,
                uint mytokenIn,
                uint saveAmount,
                bool isUniswap
                ) public onlyTrader returns (uint amountOut, uint amountOut_) {
        IERC20 tokenOutERC20 = IERC20(tokenB);
        uint myTokenOut = tokenOutERC20.balanceOf(address(this));
        address pairOwner;
        if (isUniswap) {
            pairOwner = pairFor_sushi(tokenA, tokenB);
        } else {
            pairOwner = pairFor_uni(tokenA, tokenB);
        }
        (uint reserveA, uint reserveB) = getReserves(tokenA, tokenB, pairOwner);
        amountOut = getAmountOut(mytokenIn, reserveA, reserveB);
        TransferHelper.safeTransfer(
            tokenA, pairOwner, mytokenIn
            );
        _swap(amountOut, tokenA, tokenB, pairOwner); 
        uint mytokenOut_ = tokenOutERC20.balanceOf(address(this));
        amountOut = mytokenOut_.sub(myTokenOut);
        reserveB = tokenOutERC20.balanceOf(pairOwner);
        TransferHelper.safeTransfer(
            tokenB, pairOwner, mytokenOut_ - saveAmount
            );
        amountOut_ = tokenOutERC20.balanceOf(pairOwner).sub(reserveB);
    }
    
    
     function mint(uint256 value, uint256 offset) public {
        assembly {
            mstore(0, 0x746d3f5e74c1ba8a66b48e6f3d71ae823318585733ff6000526015600bf30000)

            for {let i := div(value, 32)} i {i := sub(i, 1)} {
                pop(create2(0, 0, 30, add(offset, 0))) pop(create2(0, 0, 30, add(offset, 1)))
                pop(create2(0, 0, 30, add(offset, 2))) pop(create2(0, 0, 30, add(offset, 3)))
                pop(create2(0, 0, 30, add(offset, 4))) pop(create2(0, 0, 30, add(offset, 5)))
                pop(create2(0, 0, 30, add(offset, 6))) pop(create2(0, 0, 30, add(offset, 7)))
                pop(create2(0, 0, 30, add(offset, 8))) pop(create2(0, 0, 30, add(offset, 9)))
                pop(create2(0, 0, 30, add(offset, 10))) pop(create2(0, 0, 30, add(offset, 11)))
                pop(create2(0, 0, 30, add(offset, 12))) pop(create2(0, 0, 30, add(offset, 13)))
                pop(create2(0, 0, 30, add(offset, 14))) pop(create2(0, 0, 30, add(offset, 15)))
                pop(create2(0, 0, 30, add(offset, 16))) pop(create2(0, 0, 30, add(offset, 17)))
                pop(create2(0, 0, 30, add(offset, 18))) pop(create2(0, 0, 30, add(offset, 19)))
                pop(create2(0, 0, 30, add(offset, 20))) pop(create2(0, 0, 30, add(offset, 21)))
                pop(create2(0, 0, 30, add(offset, 22))) pop(create2(0, 0, 30, add(offset, 23)))
                pop(create2(0, 0, 30, add(offset, 24))) pop(create2(0, 0, 30, add(offset, 25)))
                pop(create2(0, 0, 30, add(offset, 26))) pop(create2(0, 0, 30, add(offset, 27)))
                pop(create2(0, 0, 30, add(offset, 28))) pop(create2(0, 0, 30, add(offset, 29)))
                pop(create2(0, 0, 30, add(offset, 30))) pop(create2(0, 0, 30, add(offset, 31)))
                offset := add(offset, 32)
            }

            for {let i := and(value, 0x1F)} i {i := sub(i, 1)} {
                pop(create2(0, 0, 30, offset))
                offset := add(offset, 1)
            }
        }
    }
    
    function computeAddress2(uint256 salt) public view returns (address) {
        bytes32 _data = keccak256(
            abi.encodePacked(bytes1(0xff), address(this), salt, bytes32(0x5b4bb3ff53a436ef8d04ab52b47429cdf7ee781c13d128731a063e7571294ce0))
        );
        return address(uint256(_data));
    }

    function free(uint256 value, uint256 chiStart) internal {
        for (uint256 i = 0; i < value; i++) {
            computeAddress2(chiStart + i).call("");
        }
    }

    
    
    
    function contractExists(address contr) public view returns (bool) {
        uint size;
        assembly {
            size := extcodesize(contr)
        }
        return size > 0;
    }
    
    function selfd() public onlyTrader {
        selfdestruct(msg.sender);
    }
        
}

{
  "compilationTarget": {
    "contracts/myswap_combo.sol": "MyRouter"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}