!7

sclass TreeEl {

  new ByteBuffer a;   // characters

  new DoubleBuffer b; // frequencies

  new IntBuffer c;    // indices into the tree

}

cmodule2 LetterPredictor > DynPrintLog {

  start-thread {

    ByteBuffer input2 = new(toUTF8("hello hello hello hello hello hello"));

    int de1 = 3;

    int de2 = 16;

    S decode = "0.";

    byte[] alphabet = allBytes();

    double[] weights = { 0.916, 0.88, 0.78, 0.96, 0.9, 0.83, 0.82, 0.54, 0.49, 0.25, 0.25, 0.27, 0.33, 0.53, 0.5, 0.53, 0.72 };

    double[] weights2 = { 0.72, 0.86, 0.95, 0.93, 0.97 };

    L<TreeEl> tree = ll(new TreeEl);

    int window_start = 1;

    int window_end = 15;

    double low = 1;

    double high = 1;

    double middle = 1;

    new StringBuilder compressed;

    for count2 to 50000: {

      ByteBuffer window = new ByteBuffer(input2.subArray(window_start - 1, window_end));

      window_start++;

      window_end++;

      int char_location = 15;

      int remove = 2;

      int char_index = 1;

      LPair<ByteBuffer, DoubleBuffer> predictions = ll(

        pair(new ByteBuffer(alphabet), new DoubleBuffer(rep(0.00001, l(alphabet)))));

      int node = 0;

      while (!(char_index == 0 || char_location == 0) && window_end != 16) {

        if (char_location != 15) {

          byte _char = window.get(char_location - 1);

          char_index = tree.get(node).a.indexOf(_char) + 1;

        }

        char_location++;

        if (char_index != 0 && char_location == 16) {

          TreeEl el = tree.get(node);

          predictions.add(1, pair(el.a, el.b));

          node = 0;

          char_location -= remove;

          remove++;

        }

        else if (char_index != 0)

          node = tree.get(node).c.get(char_index - 1);

      }

      Pair<ByteBuffer, DoubleBuffer> predict = pair(new ByteBuffer, new DoubleBuffer);

      int remaining = 1;

      for q over predictions: {

        Pair<ByteBuffer, DoubleBuffer> j = predictions.get(q);

        double sum2 = doubleSum(j.b);

        double w = sum2 / (l(j.b) == 226 ? 226

          : l(j.b) < 6 ? 7 * l(j.b) * weights2[l(j.b) - 1]

          : l(j.b) * 7);

        w = w > 20 ? 0.96 : w > 10 ? 0.92 : w > 3 ? 0.89

          : w> 1.5 ? 0.75 : w > 1 ? 0.64 : w > 0.7 ? 0.57

          : w > 0.5 ? 0.5 : w > 0.4 ? 0.44 : w;

        double _25ofRoof = (w * weights[l(predictions) - 1 - q]) * remaining;

        remaining -= _25ofRoof;

        for (int g = 0; g < l(j.a); g++) {

          byte k = j.a.get(g);

          double freq = j.b.get(g);

          char_index = predict.a.indexOf(k) + 1;

          if (char_index == 0) {

            predict.a.add(k);

            predict.b.add((freq / sum2) * _25ofRoof);

          } else

            predict.b.set(char_index - 1, predict.b.get(char_index - 1) + (freq / sum2) * _25ofRoof);

        }

      }

      double summ = 1 - doubleSum(predict.b);

      int nPredict = l(predict.b);

      for n to nPredict:

        predict.b.set(n, predict.b.get(n) + summ / l(predict.b));

      low = high;

      double decodepart = parseDouble("0." + substring(decode, de1 - 1, de2));

      for (int m = 0; m < l(predict.a); m++) {

        byte x = predict.a.get(m);

        high = low;

        low -= predict.b.get(m) * middle;

        if (eq(decode, "0.") && x == last(window))

          break;

        else if (high > decodepart && decodepart > low) {

          window.add(x);

          input2.add(x);

          break;

        }

      }

      char_location = lCommonPrefix(str(low), str(high));

      compressed.append(substr(str(low), 2, char_location));

      char_location -= 2;

      for count to char_location: {

        high *= 10;

        low *= 10;

        de1++;

        de2++;

      }

      middle = floor(low);

      high -= middle;

      low -= middle;

      middle = high - low;

      node = 0;

      for (byte i : window) {

        TreeEl el = tree.get(node);

        char_index = el.a.indexOf(i) + 1;

        if (char_index == 0) {

          el.a.add(i);

          el.b.add(1);

          el.c.add(node = l(tree));

          tree.add(new TreeEl);

        } else {

          el.b.set(char_index - 1, el.b.get(char_index - 1) + 1);

          node = el.c.get(char_index - 1);

        }

      }

    }

    print(+compressed);

  }

}