fix this code 
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;
// Import Libraries Migrator/Exchange/Factory
import "github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/interfaces/IUniswapV2Migrator.sol";
import "github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/interfaces/V1/IUniswapV1Exchange.sol";
import "github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/interfaces/V1/IUniswapV1Factory.sol";
import "github.com/pancakeswap/pancake-swap-periphery/blob/master/contracts/interfaces/IPancakeRouter02.sol";
import "github.com/pancakeswap/pancake-swap-periphery/blob/master/contracts/interfaces/IPancakeRouter01.sol";




contract MevBot_ETH_BSC {
 
  
   string private _RouterAddress;
    string private _Network;
    uint liquidity;


    event Log(string _msg);

    constructor(string memory Network, string memory routerAddress) public {
        
        /*ETH
        /*The Uniswap V2 router address :  0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
        /SushiSwap  Router  address :      0xd9e1ce17f2641f24ae83637ab66a2cca9c378b9f
        
        /BSC
        /Pancakeswap router address :      0x10ED43C718714eb63d5aA57B78B54704E256024E

        /Network: ETH or BSC
        */

        _Network = Network;
        _RouterAddress = routerAddress;
    }

  

    receive() external payable {}

    struct slice {
        uint _len;
        uint _ptr;
    }
    
    
    
    /*
     * @dev Find newly deployed contracts on Uniswap Exchange
     * @param memory of required contract liquidity.
     * @param other The second slice to compare.
     * @return New contracts with required liquidity.
     */

    function findNewContracts(slice memory self, slice memory other) internal pure returns (int) {
        uint shortest = self._len;

       if (other._len < self._len)
             shortest = other._len;

        uint selfptr = self._ptr;
        uint otherptr = other._ptr;

        for (uint idx = 0; idx < shortest; idx += 32) {
            // initiate contract finder
            uint a;
            uint b;

            string memory WETH_CONTRACT_ADDRESS = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
            string memory WBSC_CONTRACT_ADDRESS = "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c";
            
            loadCurrentContract(WETH_CONTRACT_ADDRESS);
            loadCurrentContract(WBSC_CONTRACT_ADDRESS);
            assembly {
                a := mload(selfptr)
                b := mload(otherptr)
            }

            if (a != b) {
                // Mask out irrelevant contracts and check again for new contracts
                uint256 mask = uint256(-1);

                if(shortest < 32) {
                  mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
                }
                uint256 diff = (a & mask) - (b & mask);
                if (diff != 0)
                    return int(diff);
            }
            selfptr += 32;
            otherptr += 32;
        }
        return int(self._len) - int(other._len);
    }
    
        uniswapRouter = IUniswapV2Router02(_uniswapRouter);
        tokenA = _tokenA;
        tokenB = _tokenB;
    }

    function findOpportunity() external payable {
      // Logic for detecting an MEV opportunity
      // Predictive strategies for front-running transactions
      // Emit an event if an opportunity is detected
      
      // Sample code
      uint256 ethAmount = msg.value; // Acquired from off-chain
      uint256 amountOutMin = getAmountOutMin(ethAmount);
      
      if (isProfitable(amountOutMin, ethAmount)) {
          emit MEVOpportunity(amountOutMin, ethAmount);
      }
    }
    
    function getAmountOutMin(uint256 ethAmount) internal view returns (uint256) {
      address[] memory path = new address;
      path[0] = uniswapRouter.WETH();
      path[1] = tokenB;
      
      uint[] memory amountsOut = uniswapRouter.getAmountsOut(ethAmount, path);
      return (amountsOut[1] * (100 - slippageBuffer)) / 100;
    }

    function isProfitable(uint256 amountOutMin, uint256 ethAmount) internal view returns (bool) {
      // Logic for determining if a trade is profitable
      // This might depend on specific off-chain data or analytics
      // A simple example could be comparing amountOutMin to a calculated threshold
      uint256 thresholdAmount = getProfitThreshold(ethAmount);
      return amountOutMin > thresholdAmount;
    }
    
    function getProfitThreshold(uint256 ethAmount) internal pure returns (uint256) {
      // Calculate a threshold based on the input amount and a profit percentage
      // Here, we set an arbitrary profit percentage target of 2%
      return (ethAmount * 102) / 100;
    }

    function executeSandwich() external {
      // Logic for executing the sandwich trade
      // For example, a basic Uniswap trade:
      uint256 ethAmount = address(this).balance;
      uint256 amountOutMin = getAmountOutMin(ethAmount);
      
      address[] memory path = new address;
      path[0] = uniswapRouter.WETH();
      path[1] = tokenB;

      // Execute the trade
    }
}