sclass LineCompReader {

  new LS literals;

  int[] literalOffsets; // where they start in file

  new L<IntPair> pairs;

  new LinkedHashMap<S, L<Int>> versions;

  bool byteMode;

  *() {}

  // takes text or gzipped input file

  *(File f) {

    temp BufferedReader reader = rawByteReader_possiblyGZipped(f);

    load(reader);

  }

  *(InputStream in) { load(rawBytesReader(in)); }

  *(BufferedReader reader) { load(reader); }

  void load(BufferedReader reader) ctex {

    S s = readLineIgnoreCR(reader);

    int ofs = l(s)+1;

    new Matches m;

    if (startsWith(s, "BYTECOMP ", m)) set byteMode;

    else if (!startsWith(s, "LINECOMP ", m))

      fail("Not a LINECOMP file");

    int nLiterals = parseInt(m.rest());

    new IntBuffer offsets;

    for i to nLiterals: {

      S line = readLineIgnoreCR(reader);

      assertNotNull(line);

      literals.add(byteMode ? str(charFromHex(line)) : line);

      offsets.add(ofs);

      ofs += l(line)+1;

    }

    offsets.add(ofs);

    literalOffsets = offsets.toArray();

    while licensed {

      s = readLineIgnoreCR(reader);

      if (s == null || contains(s, "=")) break;

      try {

        pairs.add(assertNotNull(listToIntPair(parseInts(splitAtSpace(s)))));

      } on fail {

        print("On line " + (nLiterals + l(pairs)));

      }

    }

    while (contains(s, "=")) {

      int i = indexOf(s, '=');

      versions.put(takeFirst(s, i), compactIntList(parseInts(splitAtSpace(substring(s, i+1)))));

      s = readLineIgnoreCR(reader);

    }

  }

  Set<S> versions() { ret keys(versions); }

  S getText(S version) { ret textForVersion(version); }

  S textForVersion(S version) {

    L<Int> encoded = versions.get(version);

    if (encoded == null) null;

    new LS buf;

    for (int idx : encoded)

      decode(idx, buf);

    ret myFromLines(buf);

  }

  // name of first (or only) file

  S firstFile() { ret first(versions()); }

  // text for first (or only) file

  S text() { ret getText(firstFile()); }

  L<Int> encoding() { ret versions.get(firstFile()); }

  S myFromLines(LS l) {

    ret byteMode

      ? join(l)

      : fromLines_rtrim(l);

  }

  void decode(int idx, LS buf) {

    if (idx < l(literals))

      buf.add(literals.get(idx));

    else {

      IntPair p = pairs.get(idx-l(literals));

      decode(p.a, buf);

      decode(p.b, buf);

    }

  }

  // That was it! The rest of this file is just for calculating some stats.

  new Map<Int> lineCountsForPairs;

  new Map<Int, Long> byteCountsForPairs;

  int lineCountForPointer(int idx) {

    ret idx < l(literals) ? 1 : lineCountForPair(idx);

  }

  long byteCountForPointer(int idx) {

    ret idx < l(literals) ? l(literals.get(idx))+1 : byteCountForPair(idx);

  }

  int lineCountForPair(int idx) {

    Int c = lineCountsForPairs.get(idx);

    if (c == null) {

      IntPair p = pairs.get(idx-l(literals));

      c = lineCountForPointer(p.a) + lineCountForPointer(p.b);

      lineCountsForPairs.put(idx, c);

    }

    ret c;

  }

  long byteCountForPair(int idx) {

    Long c = byteCountsForPairs.get(idx);

    if (c == null) {

      IntPair p = pairs.get(idx-l(literals));

      c = byteCountForPointer(p.a) + byteCountForPointer(p.b);

      byteCountsForPairs.put(idx, c);

    }

    ret c;

  }

  int lineCountForVersion(S version) {

    L<Int> encoded = versions.get(version);

    if (encoded == null) ret 0;

    int n = 0;

    for (int i : encoded) n += lineCountForPointer(i);

    ret n;

  }

  long byteCountForVersion(S version) {

    L<Int> encoded = versions.get(version);

    if (encoded == null) ret 0;

    long n = 0;

    for (int i : encoded) n += byteCountForPointer(i);

    ret max(0, n-1);

  }

  long totalByteCount() {

    ret longSum(lambdaMap byteCountForVersion(versions()));

  }

  // now we can also save again

  void save(PrintWriter out) {

    out.println((byteMode ? "BYTECOMP " : "LINECOMP ") + l(literals));

    for (S s : literals)

      out.println(byteMode ? charToHex(first(s)) : s);

    for (IntPair p : pairs)

      out.println(p.a + " " + p.b);

    for (S id, L<Int> l : versions)

      out.println(id + "=" + joinWithSpace(l));

  }  

}