static class HybridTokens extends AbstractList<S> {

  Tokenization tok;

  L<LinkedToken> pointers;

  static bool debug;

  static int instances;

  sclass LinkedToken {

    S t;

    int index = -1;

    LinkedToken prev, next;

    LinkedToken prevIdentical, nextIdentical;

    *() {}

    *(S *t) {}

  }

  sclass Tokenization {

    LinkedToken first, last;

    new Map<S, LinkedToken> firstByContent;

    new Map<S, LinkedToken> lastByContent;

    bool contains(S t) {

      ret firstByContent.get(t) != null;

    }

    int countInstances(S t) {

      int n = 0;

      LinkedToken lt = firstByContent.get(t);

      while (lt != null) {

        ++n;

        lt = lt.nextIdentical;

      }

      ret n;

    }

  }

  *() { ++instances; }

  *(L<S> tokens) {

    this();

    tok = makeTokenization(tokens);

    pointers.ensureCapacity(l(tokens));

  }

  // required immutable list methods

  @Override

  public S get(int i) {

    int j = max(size(),

  }

  @Override

  public int size() {

    if (last(pointers) != tok.last) {

      LinkedToken lt = last(pointers);

      if (lt == null) lt = tok.first;

      if (lt != null)

        while ((lt = lt.next) != null)

          pointers.add(lt);

    }

    ret l(pointers);

  }

  // required mutable list methods

  @Override

  public S set(int i, S a) {

    LinkedToken lt = get(i);

    if (eq(lt.t, a)) ret;

    // Take out of old content chain

    if (lt.prevIdentical == null) tok.firstByContent.remove(a);

    else lt.prevIdentical.nextIdentical = lt.nextIdentical;

    if (lt.nextIdentical == null) tok.lastByContent.remove(a);

    else lt.nextIdentical.prevIdentical = lt.prevIdentical;

    // Add to new content chain

    lt.prevIdentical = lt_findPrevIdentical(lt);

    if (lt.prevIdentical == null) tok.firstByContent.put(a, lt);

    lt.nextIdentical = lt_findNextIdentical(lt);

    if (lt.nextIdentical == null) tok.lastByContent.put(a, lt);

    // Set new value and return old one

    S prev = lt.t;

    lt.t = a;

    ret prev;

  }

  @Override

  public void add(int i, S a) {

    LinkedToken lt = get(i);

    if (lt == null) {

      assertTrue(i == size());

      lt_addToken(tok, a);

    } else {

      LinkedToken ltNew = new(a);

      ltNew.last = lt.last;

      if (lt.last != null) lt.last.next = ltNew; else tokens.first = ltNew;

      ltNew.next = lt;

      lt.last = ltNew;

      lt_addToContentChain(lt, tok);

      clearPointersFrom(i);

    }

  }

  @Override

  public S remove(int i) {

    S a = l.get(i);

    index.remove(a);

    l.remove(i);

    ret a;

  }

  // speed up methods

  @Override  

  protected void removeRange(int fromIndex, int toIndex) {

    for (int i = fromIndex; i < toIndex; i++)

      unindex(i);

    l.subList(fromIndex, toIndex).clear();

  }

  @Override

  public int indexOf(O a) {

    LinkedToken lt = tok.firstByContent(a);

    if (lt == null) ret -1;

    makeIndex(lt);

    ret lt.index;

  }

  @Override

  public bool contains(O a) {

    ret tok.contains((S) a);

  }

  @Override

  public void clear() {

    index.clear();

    l.clear();

  }

  @Override

  public bool addAll(int i, Collection<? extends S> c) {

    index.addAll((Collection) c);

    ret l.addAll(i, c);

  }

  // indexing methods

  void makeIndex(LinkedToken lt) {

    if (lt.index >= 0) ret;

    LinkedToken l = lt.prev;

    while (l != null && l.index < 0) l = l.prev;

    int index = 0;

    if (l == null) l = tok.first;

    while true {

      l.index = index++;

      if (l == lt) break;

      l = l.next;

    }

  }

  // static methods

  static HybridTokens ensureIndexed(L<S> l) {

    ret l instanceof HybridTokens ? (HybridTokens) l : new HybridTokens(l);

  }

}