static class Patterns extends P {
  Map<L<S>,S> map = new HashMap<L<S>,S>();
  int n;

  *(int *n) {
  }
  
  S read(S file, L<S> tok) {
    prepare(file);
    
    while (tok.size() > seen) {
      ++seen;
      if (seen > n)
        put(new ArrayList<S>(tok.subList(seen-n-1, seen-1)), tok.get(seen-1));
    }
    
    if (tok.size() >= n) {
      L<S> l = new ArrayList<S>(tok.subList(tok.size()-n, tok.size()));
      for (L<S> pl : map.keySet()) {
        S pr = map.get(pl);
        //print("pl: " + structure(pl) + ", l: " + structure(l));
        Map<S, S> m = makeMapPrefix(pl, l);
        if (m != null) {
          S result = m.get(pr);
          //print("map: " + structure(m) + ", result: " + quote(result));
          ret result;
        }
      }
    }
      
    return null;
  }
  
  void put(L<S> l, S r) {
    if (isPattern(l, r)) {
      new L<S> l2;
      l2.addAll(l);
      l2.add(r);
      //print("pattern: " + structure(l2));
      map.put(l, r);
    }
  }
  
  boolean isPattern(L<S> l, S r) {
    /*new Set<S> set;
    set.addAll(l);
    set.add(r);
    return set.size() < l.size()+1;*/
    return l.contains(r) && interestingToken(r);
  }
   
  boolean interestingToken(S r) {
    //return !r.trim().equals("");
    for (int i = 0; i < r.length(); i++)
      if (Character.isLetter(r.charAt(i)))
        ret true;
    ret false;
  }
  
  P derive() {
    Patterns t = new Patterns(n);
    t.map = new DerivedHashMap<L<S>,S>(map);
    return t;
  }
  
  P clear() {
    return new Patterns(n);
  }
}