// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity >=0.4.0;

// computes square roots using the babylonian method
// https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method
library Babylonian {
    function sqrt(uint256 y) internal pure returns (uint256 z) {
        if (y > 3) {
            z = y;
            uint256 x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
        // else z = 0
    }
}

pragma solidity >=0.5.0;

interface IERC20 {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
}

pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

pragma solidity >=0.6.2;

import './IUniswapV2Router01.sol';

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

pragma solidity >=0.5.0;

interface IWETH {
    function deposit() external payable;
    function transfer(address to, uint value) external returns (bool);
    function withdraw(uint) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity >=0.6.0;

// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
    }

    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
    }

    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
    }

    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
    }
}

pragma solidity =0.6.6;

//import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
//import '@uniswap/lib/contracts/libraries/Babylonian.sol';
import "github.com/Uniswap/uniswap-lib/blob/master/contracts/libraries/Babylonian.sol";
//import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
import "github.com/Uniswap/uniswap-lib/blob/master/contracts/libraries/TransferHelper.sol";
//import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
import "github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/interfaces/IUniswapV2Router02.sol";
//import "@openzeppelin/contracts/math/SafeMath.sol";
import "github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/SafeMath.sol";

import './interfaces/IERC20.sol';
import './interfaces/IWETH.sol';
import './gt.sol';


interface GST2 {
  function freeUpTo(uint256 value) external returns (uint256 freed);  
}

contract qsunibotowngt is gt{
  using SafeMath for uint;

  address payable public owner;
  uint private key = 1408105436484778832557076762263394370022170234737;
  uint gstamount1 = 3;
  uint gstamount2 = 1;

  mapping(address => bool) public admins;



  IUniswapV2Router02 public router = IUniswapV2Router02(address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D));
  address public factory = address(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
  address wethaddr = router.WETH();
  GST2 gst2 = GST2(address(0x0000000000b3F879cb30FE243b4Dfee438691c04));


  //address public owningtoken;
  bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));


  constructor() public {
    owner = msg.sender;
  }


  modifier onlyowner{
    require(msg.sender == owner);
    _;
  }

  modifier onlyadmin {
    require(admins[msg.sender] == true || msg.sender == owner);
    _;
  }

  receive() external payable {}


  function setadmin(address newadmin) external onlyowner{
    admins[newadmin] = true;
  }


  function setparam(address factoryin, address routerin, address gt2) external onlyowner{
    factory = factoryin;
    router = IUniswapV2Router02(routerin);
    wethaddr = router.WETH();
    gst2 = GST2(gt2);
    //owningtoken = owningtokenin;
  }
  
  function setgtamount(uint f, uint s) external onlyowner{
  	gstamount1 = f;
  	gstamount2 = s;
  }


  function setkey(uint newkey) external onlyowner{
  	key = newkey;
  }
  
  function deposit() payable external{
  }


  function _safeTransfer(address token, address to, uint value) private {
    (bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
    //require(success && (data.length == 0 || abi.decode(data, (bool))), 'UniswapV2: TRANSFER_FAILED');
  }

  function withdrawtoken(address tokenaddr, uint amount) external onlyowner{
    _safeTransfer(tokenaddr, owner, amount);
  }

  function withdrawtokenall(address tokenaddr) external onlyowner{
    //IERC20(tokenaddr).transfer(owner, IERC20(tokenaddr).balanceOf(address(this)));
    _safeTransfer(tokenaddr, owner, IERC20(tokenaddr).balanceOf(address(this)));
  }

  function withdrawethall() external onlyowner {
    msg.sender.transfer(address(this).balance);
  }

  function withdrawethamount(uint amount) external onlyowner {
    msg.sender.transfer(amount);
  }


  function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
      require(amountIn > 0, 'AMOUNT');
      require(reserveIn > 0 && reserveOut > 0, 'LIQUIDITY');
      uint amountInWithFee = amountIn.mul(997);
      uint numerator = amountInWithFee.mul(reserveOut);
      uint denominator = reserveIn.mul(1000).add(amountInWithFee);
      amountOut = numerator / denominator;
  } 


  function swapexactethfortokensowngt(uint256 param1, uint256 param2, uint256 entokenaddr)external onlyadmin{
    bool firsttoken = param1 >> 254 == 1;
    bool usgt = param1 >> 253 & 1 == 1;
    bool usgt2 = param1 >> 252 & 1 == 1;
    uint256 enpool = param1 & 0x00ffffffffffffffffffffffffffffffffffffffff;

    uint256 amountIn = param2 >> 128;
    uint targetreserve = param2 & 0x00ffffffffffffffffffffffffffffffff;


    bytes memory returnData;
    address pool = address(enpool ^ key);
    (, returnData) = pool.staticcall(abi.encodeWithSelector(0x0902f1ac));
    (uint reserve0,uint reserves1, ) = abi.decode(returnData, (uint,uint,uint)); // getreserve

    (uint reserveInput, uint reserveOutput) = (firsttoken) ? (reserves1, reserve0) : (reserve0, reserves1);

    if (reserveOutput >= targetreserve){
      address tokenaddr = address(entokenaddr ^ key);

      wethaddr.call(abi.encodeWithSelector(0xa9059cbb, pool, amountIn)); // transfer
      uint amountOut = getAmountOut(amountIn, reserveInput, reserveOutput);
      (uint amount0Out, uint amount1Out) = (firsttoken) ? (amountOut,uint(0)) : (uint(0),amountOut);
      pool.call(abi.encodeWithSelector(0x022c0d9f, amount0Out, amount1Out, address(this), new bytes(0)));

      //(,returnData) = tokenaddr.call(abi.encodeWithSelector(0x70a08231,address(this))); //balanceOf
      //(uint tokenbalance) = abi.decode(returnData, (uint));
      //require(tokenbalance > 0, "fs1");
      
      
	  if(usgt){
	    freeqsgt(gstamount1);
	  }
	  return;
    }

    if(usgt2){
      freeqsgt(gstamount2);
    }
  }


  function swapexactethfortokensgt(uint256 param1, uint256 param2, uint256 entokenaddr)external onlyadmin{
    bool firsttoken = param1 >> 254 == 1;
    bool usgt = param1 >> 253 & 1 == 1;
    bool usgt2 = param1 >> 252 & 1 == 1;
    uint256 enpool = param1 & 0x00ffffffffffffffffffffffffffffffffffffffff;

    uint256 amountIn = param2 >> 128;
    uint targetreserve = param2 & 0x00ffffffffffffffffffffffffffffffff;


    bytes memory returnData;
    address pool = address(enpool ^ key);
    (, returnData) = pool.staticcall(abi.encodeWithSelector(0x0902f1ac));
    (uint reserve0,uint reserves1, ) = abi.decode(returnData, (uint,uint,uint)); // getreserve

    (uint reserveInput, uint reserveOutput) = (firsttoken) ? (reserves1, reserve0) : (reserve0, reserves1);

    if (reserveOutput >= targetreserve){
      address tokenaddr = address(entokenaddr ^ key);

      wethaddr.call(abi.encodeWithSelector(0xa9059cbb, pool, amountIn)); // transfer
      uint amountOut = getAmountOut(amountIn, reserveInput, reserveOutput);
      (uint amount0Out, uint amount1Out) = (firsttoken) ? (amountOut,uint(0)) : (uint(0),amountOut);
      pool.call(abi.encodeWithSelector(0x022c0d9f, amount0Out, amount1Out, address(this), new bytes(0)));
      
      //(,returnData) = tokenaddr.call(abi.encodeWithSelector(0x70a08231,address(this))); //balanceOf
      //(uint tokenbalance) = abi.decode(returnData, (uint));
      //require(tokenbalance > 0, "fs1");

	  if(usgt){
	    gst2.freeUpTo(gstamount1);
	  }
	  return;
    }

    if(usgt2){
      gst2.freeUpTo(gstamount2);
    }
  }


  function swapexacttokenforethfeeon(address pool, uint256 param) external payable onlyadmin{
    //uint256 gasStart = gasleft();
    bytes memory returnData;

    address tokenaddr = address(param & 0x00ffffffffffffffffffffffffffffffffffffffff);
    bool firsttoken = param >> 160 == 1;

    (,returnData) = tokenaddr.call(abi.encodeWithSelector(0x70a08231,address(this)));
    (uint tokenbalance) = abi.decode(returnData, (uint));
  	if (tokenbalance > 0){

      (, returnData) = pool.staticcall(abi.encodeWithSelector(0x0902f1ac));
      (uint reserves0, uint reserves1, ) = abi.decode(returnData, (uint,uint,uint)); // getreserve

      tokenaddr.call(abi.encodeWithSelector(0xa9059cbb, pool, tokenbalance));

      (uint reserveIn, uint reserveOut) = firsttoken ? (reserves0, reserves1) : (reserves1, reserves0);// the reservein is that erc20 token not weth
      uint amountInput = IERC20(tokenaddr).balanceOf(pool).sub(reserveIn);
      uint amountOutput = getAmountOut(amountInput, reserveIn, reserveOut);

      (uint amount0Out, uint amount1Out) = firsttoken ? (uint(0), amountOutput) : (amountOutput, uint(0));

      pool.call(abi.encodeWithSelector(0x022c0d9f, amount0Out, amount1Out, address(this), new bytes(0)));

  	}

  }


  function destory() external onlyowner{
    selfdestruct(owner);
  }
}

pragma solidity =0.6.6;

import "./rlp.sol";

contract gt is Rlp{
    uint256 s_head;
    uint256 s_tail;

    // Creates a child contract that can only be destroyed by this contract.
    function makeChild() internal returns (address addr) {
        bytes memory bytecode = hex"6133ff6000526002601ef3";
        address addr;
        uint256 value = 0;
        assembly {
            addr := create(value, add(bytecode, 0x20), mload(bytecode))
        }

        //require(addr != 0, "Contract creation failed.");
    }


    function totalSupply() public view returns (uint256 supply) {
        return s_head - s_tail;
    }

	function mintqsgt(uint256 value) public {
        for (uint256 i = 0; i < value; i++) {
            makeChild();
        }
        s_head += value;
    }


    function freeqsgt(uint256 value) public {
        uint256 tail = s_tail;
        // tail points to slot behind the last contract in the queue
        for (uint256 i = tail + 1; i <= tail + value; i++) {
            mk_contract_address(address(this), i).call("");
        }

        s_tail = tail + value;
    }


    /*
    function destroyChildren(uint256 value) internal {
        uint256 tail = s_tail;
        // tail points to slot behind the last contract in the queue
        for (uint256 i = tail + 1; i <= tail + value; i++) {
            mk_contract_address(address(this), i).call("");
        }

        s_tail = tail + value;
    }

    function freeqsgt(uint256 value) public returns (bool success) {
    	uint total = totalSupply();
    	if (total == 0){
    		return false;
    	}
        if (value > total) {
            value = total;
        }

        destroyChildren(value);

        return true;
    }
    */
}

pragma solidity =0.6.6;

contract Rlp {

    uint256 constant ADDRESS_BYTES = 20;
    uint256 constant MAX_SINGLE_BYTE = 128;
    uint256 constant MAX_NONCE = 256**9 - 1;

    // count number of bytes required to represent an unsigned integer
    function count_bytes(uint256 n) pure internal returns (uint256 c) {
        uint i = 0;
        uint mask = 1;
        while (n >= mask) {
            i += 1;
            mask *= 256;
        }

        return i;
    }

    function mk_contract_address(address a, uint256 n) pure internal returns (address rlp) {
        /*
         * make sure the RLP encoding fits in one word:
         * total_length      1 byte
         * address_length    1 byte
         * address          20 bytes
         * nonce_length      1 byte (or 0)
         * nonce           1-9 bytes
         *                ==========
         *                24-32 bytes
         */
        require(n <= MAX_NONCE);

        // number of bytes required to write down the nonce
        uint256 nonce_bytes;
        // length in bytes of the RLP encoding of the nonce
        uint256 nonce_rlp_len;

        if (0 < n && n < MAX_SINGLE_BYTE) {
            // nonce fits in a single byte
            // RLP(nonce) = nonce
            nonce_bytes = 1;
            nonce_rlp_len = 1;
        } else {
            // RLP(nonce) = [num_bytes_in_nonce nonce]
            nonce_bytes = count_bytes(n);
            nonce_rlp_len = nonce_bytes + 1;
        }

        // [address_length(1) address(20) nonce_length(0 or 1) nonce(1-9)]
        uint256 tot_bytes = 1 + ADDRESS_BYTES + nonce_rlp_len;

        // concatenate all parts of the RLP encoding in the leading bytes of
        // one 32-byte word
        uint256 word = ((192 + tot_bytes) * 256**31) +
                       ((128 + ADDRESS_BYTES) * 256**30) +
                       (uint256(a) * 256**10);

        if (0 < n && n < MAX_SINGLE_BYTE) {
            word += n * 256**9;
        } else {
            word += (128 + nonce_bytes) * 256**9;
            word += n * 256**(9 - nonce_bytes);
        }

        uint256 hash;

        assembly {
            let mem_start := mload(0x40)        // get a pointer to free memory
            mstore(mem_start, word)             // store the rlp encoding
            hash := keccak256(mem_start,
                         add(tot_bytes, 1))     // hash the rlp encoding
        }

        // interpret hash as address (20 least significant bytes)
        return address(hash);
    }
}

{
  "compilationTarget": {
    "browser/bot.sol": "qsunibotowngt"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}