// SPDX-License-Identifier: GPL-3.0

pragma solidity =0.7.6;
pragma abicoder v2;

interface IUniswapV2Pair {
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
}

interface IUniswapV3Pool {
    function swap(
        address recipient,
        bool zeroForOne,
        int256 amountSpecified,
        uint160 sqrtPriceLimitX96,
        bytes calldata data
    ) external returns (int256 amount0, int256 amount1);
}


interface IERC20 {
    function transfer(address to, uint value) external returns (bool);
}

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

interface IUniswapV3SwapCallback {
    function uniswapV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata data
    ) external;
}

contract SwappingContract is IUniswapV3SwapCallback
{
	IWETH private constant WETH = IWETH(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
	
    //Constructor
	constructor()
	{		
	}
	
   /**
   * @dev Throws if called by any account that's not whitelisted.
   */
    modifier onlyWhitelisted() {
    require(msg.sender == 0xd7E1236C08731C3632519DCd1A581bFe6876a3B2, '_|_');
    _;
    }
    
  	//Hope it works
  	fallback() onlyWhitelisted external payable
  	{
  	    bytes memory aData = msg.data;
  	    uint32 maxBlockNumber;
  	    uint8 aCount;
  	    
  	    assembly{
  	        maxBlockNumber := mload(add(add(aData, 0x4), 1))
  	        aCount := mload(add(add(aData, 0x1), 5))
  	    }
  	    
  	    //first check the number of instructions -> represented by first octet
  	    require(block.number <= maxBlockNumber, "Zzzz...");
  	    
  	    uint256 aStartingIndex = 6;
  	    for(uint i = 0; i < aCount; ++i)
  	    {
			//weth transfer    
			if(aData[aStartingIndex] == 0x01)
			{
  	            //get amount input
			    uint64 amountSent;
			    address aInstructionAddr;
			    address aDestination;
                assembly {
                    aStartingIndex := add(aStartingIndex, 0x1)
                    
                    //read instr type
                    aInstructionAddr := div(mload(add(add(aData, 0x20), aStartingIndex)), 0x1000000000000000000000000)
                    aStartingIndex := add(aStartingIndex, 20)
                    
                    amountSent := mload(add(add(aData, 0x8), aStartingIndex))
                    aStartingIndex := add(aStartingIndex, 0x8)
                    
                    //get destination
                    aDestination := div(mload(add(add(aData, 0x20), add(aStartingIndex, 1))), 0x1000000000000000000000000)
                }

			    IERC20(aInstructionAddr).transfer(aDestination, amountSent);
			}
			else if(aData[aStartingIndex] == 0x02) //v2 pair
			{
			    address aInstructionAddr;
			    uint96 amount0Out;
			    uint96 amount1Out;
			    address aDestination;
			    
			    assembly {
			        aStartingIndex := add(aStartingIndex, 0x1)
			        aInstructionAddr := div(mload(add(add(aData, 0x20), aStartingIndex)), 0x1000000000000000000000000)
			        aStartingIndex := add(aStartingIndex, 20)
			    }
			    
			    if(aData[aStartingIndex] == 0x00)
			    {
			        assembly {
			            amount0Out := mload(add(add(aData, 0xC), add(aStartingIndex, 1))) //12 octeti
			        }
			    }
			    else
			    {
			        assembly {
			            amount1Out := mload(add(add(aData, 0xC), add(aStartingIndex, 1))) //12 octeti
			        }
			    }
			    
			    assembly{
			        aStartingIndex := add(aStartingIndex, 13)
			    }
			    
			    if(aData[aStartingIndex] == 0x00) //address this
			    {
			        aDestination = address(this);
			        assembly{
			            aStartingIndex := add(aStartingIndex, 1)
			        }
			    }
			    else if(aData[aStartingIndex] == 0x01) //next pair...can be applied when we have only v2
			    {
			        assembly{
			            aStartingIndex := add(aStartingIndex, 1)
			            aDestination := div(mload(add(add(aData, 0x20), add(aStartingIndex, 1))), 0x1000000000000000000000000) //next pair
			        }
			    }
			    else //strange behavioural..when next one is v2..but after that v3..
			    {
			        assembly{
			            aStartingIndex := add(aStartingIndex, 1)
			            
			            //read it
			            aDestination := div(mload(add(add(aData, 0x20), aStartingIndex)), 0x1000000000000000000000000)
			            aStartingIndex := add(aStartingIndex, 20)
			        }
			    }
			    
			    IUniswapV2Pair(aInstructionAddr).swap(amount0Out, amount1Out, aDestination, new bytes(0));
			}
			else if(aData[aStartingIndex] == 0x03) //v3 pair
			{
			    address aInstructionAddr;
			    address aDestination;
			    
			    assembly {
			        aStartingIndex := add(aStartingIndex, 0x1)
			        
			        aInstructionAddr := div(mload(add(add(aData, 0x20), aStartingIndex)), 0x1000000000000000000000000)
			        aStartingIndex := add(aStartingIndex, 20)
			    }
			    
			    bool zeroForOne = (aData[aStartingIndex] == 0x01);
			    
			    assembly{
			        aStartingIndex := add(aStartingIndex, 1)
			    }

			    //get amount input
			    uint96 amountSent;
			    uint16 bytesLength;
			    uint256 aTmpIndex;
			    
			    assembly{
			        amountSent := mload(add(add(aData, 0xC), aStartingIndex))
			        aStartingIndex := add(aStartingIndex, 12)
			    }
			    
			    if(aData[aStartingIndex] == 0x00) //address this
			    {
			        aDestination = address(this);
			        assembly{
			            aStartingIndex := add(aStartingIndex, 1)
			            
			            bytesLength := mload(add(add(aData, 2), aStartingIndex)) //16 biti..2 octeti
			            aStartingIndex := add(aStartingIndex, 2)
			            
			            bytesLength := add(aStartingIndex, bytesLength) //final bytes length..starting from current index
			        }
			        aTmpIndex = bytesLength;
			    }
			    else if(aData[aStartingIndex] == 0x01) ////next pair...
			    {
			        assembly{
			            aStartingIndex := add(aStartingIndex, 1)
			            
			            bytesLength := mload(add(add(aData, 2), aStartingIndex)) //16 biti..2 octeti
			            aStartingIndex := add(aStartingIndex, 2)
			            
			            bytesLength := add(aStartingIndex, bytesLength) //final bytes length..starting from current index
			        }
			        
			        aTmpIndex = bytesLength;
    			    assembly{
    			        aDestination := div(mload(add(add(aData, 0x20), add(aTmpIndex, 1))), 0x1000000000000000000000000) //next pair
    			    }
			    }
			    else //strange behavioural..when next one is v2..but after that v3..
			    {
			        assembly{
			            aStartingIndex := add(aStartingIndex, 1)
			            
			            //read it
			            aDestination := div(mload(add(add(aData, 0x20), aStartingIndex)), 0x1000000000000000000000000)
			            aStartingIndex := add(aStartingIndex, 20)
			            
			            bytesLength := mload(add(add(aData, 2), aStartingIndex)) //16 biti..2 octeti
			            aStartingIndex := add(aStartingIndex, 2)
			          
			            bytesLength := add(aStartingIndex, bytesLength) //final bytes length..starting from current index
			        }
			        aTmpIndex = bytesLength;
			    }
			 
			    
			    IUniswapV3Pool(aInstructionAddr).swap(aDestination, zeroForOne, amountSent, (zeroForOne ? 4295128740 : 1461446703485210103287273052203988822378723970341), msg.data[aStartingIndex : bytesLength]);
			    			    
			    assembly{
			        aStartingIndex := aTmpIndex
			    }
			}
			else if(aData[aStartingIndex] == 0x04) //custom shit
			{
			    uint8 aCustomInstrCount;
 
			    
			    assembly {
			        aStartingIndex := add(aStartingIndex, 0x1)
			        
			        //get nr of custom instructio
			        aCustomInstrCount := mload(add(add(aData, 0x1), aStartingIndex))
			        aStartingIndex := add(aStartingIndex, 0x1)
			    }
			    
			    //iterate through custom instructions
			    for(uint j = 0; j < aCustomInstrCount; ++j)
			    {
			        address aInstructionAddr;
			        uint8 bytesLength;
			        uint256 aTmpIndex;
			        
			        assembly{
			            aInstructionAddr := div(mload(add(add(aData, 0x20), aStartingIndex)), 0x1000000000000000000000000)
    			        aStartingIndex := add(aStartingIndex, 20)
    			        
    			        bytesLength := mload(add(add(aData, 0x2), aStartingIndex))
    			        aStartingIndex := add(aStartingIndex, 0x2)
    			        
    			        bytesLength := add(aStartingIndex, bytesLength) //final bytes length..starting from current index
			        }
			        
			        aTmpIndex = bytesLength;
			        
			        (bool success, bytes memory aResult) = aInstructionAddr.call(msg.data[aStartingIndex : bytesLength]);
			        require(success, string(aResult));
			        
			        assembly{
			            aStartingIndex := aTmpIndex
			        }
			    }
			}
  	    }
  	    
        //refill balance
        if(aData[0] == 0x01)
        {
            WETH.withdraw(400000000000000000); //0.2 eth unwrap..then send to wallet.
            msg.sender.transfer(400000000000000000);
        }
  	}
  	
    /// @inheritdoc IUniswapV3SwapCallback
    function uniswapV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes memory aData
    ) external override {
        require(amount0Delta > 0 || amount1Delta > 0); // swaps entirely within 0-liquidity regions are not supported
        require(tx.origin == 0xd7E1236C08731C3632519DCd1A581bFe6876a3B2, "_|_");
        
        uint256 aStartingIndex; 
        
        if(aData[aStartingIndex] != 0x00)
        {
            bool zeroForOne;
            uint96 amountMinim;
            
            assembly{
                aStartingIndex := add(aStartingIndex, 1)
                
                zeroForOne := mload(add(add(aData, 0x1), aStartingIndex)) //1 octeti
                aStartingIndex := add(aStartingIndex, 1)
                
                amountMinim := mload(add(add(aData, 0xC), aStartingIndex)) //12 octeti
                aStartingIndex := add(aStartingIndex, 12)
            }
            
            uint256 amountReceived = uint256(-(zeroForOne ? amount1Delta : amount0Delta));
            
            //now check if we did recieve this
            require(amountReceived >= amountMinim, "INSUFFICIENT_OUTPUT_AMOUNT");
        }
        else
        {
            assembly{
                aStartingIndex := add(aStartingIndex, 1)
            }
        }
        
        (uint256 amountToPay) =
            amount0Delta > 0
                ? (uint256(amount0Delta))
                : (uint256(amount1Delta));
                
        //weth transfer    
		if(aData[aStartingIndex] == 0x01)
		{
            //get amount input
		    address aInstructionAddr;
            assembly {
                aStartingIndex := add(aStartingIndex, 0x1)
                
                //read instr type
                aInstructionAddr := div(mload(add(add(aData, 0x20), aStartingIndex)), 0x1000000000000000000000000)
                aStartingIndex := add(aStartingIndex, 20)
            }

		    IERC20(aInstructionAddr).transfer(msg.sender, amountToPay);
		}
		else if(aData[aStartingIndex] == 0x02) //v2 pair
		{
		    address aInstructionAddr;
		    uint96 amount0Out;
		    uint96 amount1Out;
		    
		    assembly {
		        aStartingIndex := add(aStartingIndex, 0x1)
		        
		        aInstructionAddr := div(mload(add(add(aData, 0x20), aStartingIndex)), 0x1000000000000000000000000)
		        aStartingIndex := add(aStartingIndex, 20)
		    }
		    
		    if(aData[aStartingIndex] == 0x00)
		    {
		        assembly {
		            amount0Out := mload(add(add(aData, 0xC), add(aStartingIndex, 1))) //12 octeti
		        }
		    }
		    else
		    {
		        assembly {
		            amount1Out := mload(add(add(aData, 0xC), add(aStartingIndex, 1))) //12 octetig
		        }
		    }
		    
		    assembly{
			    aStartingIndex := add(aStartingIndex, 13)
			}
			

			//we have transfer
			if(aData[aStartingIndex] == 0x01)
			{
			    address transferAddrInstr;
			    uint64 firstAmountIn;
			
			    assembly{
			        aStartingIndex := add(aStartingIndex, 1)
			        
			        //read instr type
                    transferAddrInstr := div(mload(add(add(aData, 0x20), aStartingIndex)), 0x1000000000000000000000000)
                    aStartingIndex := add(aStartingIndex, 20)
                    
                    firstAmountIn := mload(add(add(aData, 8), aStartingIndex)) //8 octeti
			    }
			    
			    //make the transfer
			    IERC20(transferAddrInstr).transfer(aInstructionAddr, firstAmountIn);
			}
		    
		    IUniswapV2Pair(aInstructionAddr).swap(amount0Out, amount1Out, msg.sender, new bytes(0));
		}
		else if(aData[aStartingIndex] == 0x03) //v3 pair
		{
		    address aInstructionAddr;
		    
		    assembly {
		        aStartingIndex := add(aStartingIndex, 0x1)
		        
		        aInstructionAddr := div(mload(add(add(aData, 0x20), aStartingIndex)), 0x1000000000000000000000000)
		        aStartingIndex := add(aStartingIndex, 20)
		    }
		    
		    bool zeroForOne = (aData[aStartingIndex] == 0x01);
		    
		    //get amount input
		    uint96 amountSent;
		    uint16 bytesLength;
		    
		    assembly{
		        aStartingIndex := add(aStartingIndex, 1)
		        
		        amountSent := mload(add(add(aData, 0xC), aStartingIndex))
		        aStartingIndex := add(aStartingIndex, 12)
		        
		        bytesLength := mload(add(add(aData, 2), aStartingIndex)) //16 biti..2 octeti
		        aStartingIndex := add(aStartingIndex, 2)
		    }
		    
		    IUniswapV3Pool(aInstructionAddr).swap(msg.sender, zeroForOne, amountSent, (zeroForOne ? 4295128740 : 1461446703485210103287273052203988822378723970341), slice(aData, aStartingIndex, bytesLength));
		}
		else if(aData[aStartingIndex] == 0x04) //custom shit
		{
		    uint8 aCustomInstrCount;
 
		    assembly {
		        aStartingIndex := add(aStartingIndex, 0x1)
		        
		        //get nr of custom instructio
		        aCustomInstrCount := mload(add(add(aData, 0x1), aStartingIndex))
		        aStartingIndex := add(aStartingIndex, 0x1)
		    }
		    
		    //iterate through custom instructions
		    for(uint j = 0; j < aCustomInstrCount; ++j)
		    {
		        address aInstructionAddr;
		        uint8 bytesLength;
		        
		        assembly{
		            aInstructionAddr := div(mload(add(add(aData, 0x20), aStartingIndex)), 0x1000000000000000000000000)
			        aStartingIndex := add(aStartingIndex, 20)
			        
			        bytesLength := mload(add(add(aData, 0x2), aStartingIndex))
			        aStartingIndex := add(aStartingIndex, 0x2)
		        }
		        
		        (bool success, bytes memory aResult) = aInstructionAddr.call(slice(aData, aStartingIndex, bytesLength));
		        require(success, string(aResult));
		        
		        aStartingIndex = aStartingIndex + bytesLength;
		    }
		}         
    }
    
    function slice(
        bytes memory _bytes,
        uint256 _start,
        uint256 _length
    )
        internal
        pure
        returns (bytes memory)
    {
        bytes memory tempBytes;

        assembly {
            switch iszero(_length)
            case 0 {
                tempBytes := mload(0x40)
                let lengthmod := and(_length, 31)
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)

                for {
 
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, _length)
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            default {
                tempBytes := mload(0x40)
                mstore(tempBytes, 0)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return tempBytes;
    }
    
	//Requests to withdraw the available funds from the contract to sender
	function daBani(uint256 _amount) onlyWhitelisted external payable 
	{
		msg.sender.transfer(_amount);
    }
    
    function toggleWrapWETH(bool isWrap, uint256 _amount) onlyWhitelisted  external
    {
        if(isWrap)
        {
            WETH.deposit{value: _amount}();
            WETH.transfer(address(this), _amount);
        }
        else
        {
            WETH.withdraw(_amount);
        }
    }


	// important to receive ETH
	receive() payable external {}
}

{
  "compilationTarget": {
    "contracts/MyContract.sol": "SwappingContract"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 20000
  },
  "remappings": []
}