anchor.diff:              _pastEnd.Add(p, f) |> ignore
           else
               let tuple = (p, s)
  -            match backlinks.TryGetValue(s) with
  -            | true, parsers-> 
  +
  +            while backlinks.Count <= s do backlinks.Add(null)
  +            if backlinks.[s] <> null then
  +                let parsers = backlinks.[s]
                   if not <| parsers.ContainsKey(p) then 
                       parsers.Add(p, new FSet<'a>() )
  -            | _, _ ->
  +            else
                   let nmap = new HOMap<GParser<'a>, FSet<'a> >() in nmap.Add(p, new FSet<'a>())
  -                backlinks.Add(s, nmap)
  +                backlinks.[s] <- nmap
   
               backlinks.[s].[p].Add(f) |> ignore
   
  -            match popped.TryGetValue(s) with
  -            | true, parsers when parsers.ContainsKey p ->
  +            if s < popped.Count && popped.[s] <> null && popped.[s].ContainsKey p then
  +                let parsers = popped.[s]
                   //foundInPopped <- foundInPopped + 1
                   parsers.[p] |> Seq.toArray |> Seq.iter(fun res ->            // if we've already done that, use the result
                       trace(lazy(sprintf "Revisited: %A *=> %A\n" tuple res))
                       f res )
               
  -            | _ ->
  +            else
       //            if not (_done.ContainsKey s) then _done.Add(s, new HashSet<GParser<'a> >())
       //            if not (_done.[s].Contains p) then 
       //                _queue.Add(tuple)
       //                _done.[s].Add(p) |> ignore
   
  -                //notFoundInPopped <- notFoundInPopped + 1
                   let addTuple(parsers: HashSet<GParser<'a> >) = 
  -                    //notFoundInDone <- notFoundInDone + 1
                       _queue.Add(tuple)
                       parsers.Add(p) |> ignore
                       trace(lazy(sprintf "Added: %A\n" tuple))
  -                    //queuePushed <- queuePushed + 1
  -
  -                match _done.TryGetValue(s) with
  -                | true, parsers ->
  +
  +                while _done.Count <= s do _done.Add(null)
  +                if _done.[s] <> null then
  +                    let parsers = _done.[s]
                       if not <| parsers.Contains (p) then 
                           addTuple(parsers) 
  -                | _, _ ->
  +                else
                       let parsers = new HashSet<GParser<'a> >()
  -                    _done.Add(s, parsers)
  -                    //savedToDone <- savedToDone + 1
  +                    _done.[s] <- parsers
                       addTuple(parsers)
   
   #nowarn "1189"
  
positive.code: //        else 
          p.Chain (tram, s) cont
          
      member this.Stream with get () : InputStream<'a> = stream and set (value : InputStream<'a>) = stream <- value
      member this.Saved  = saved
      member this.Popped = popped
      member this.Done   = _done
      member this.Backlinks = backlinks
      member this.Postrace = postrace
      member this.Queue = _queue
      member this.PastEnd : HashSet<GParser<'a> * Continuation<'a> > = _pastEnd
      member this.Stop() : unit = stopped <- true
  
      member this.PrepareReparse (ind: StreamIndex) : unit = 
          _pastEnd.Clear()
          _done.Keys 
          |> Seq.filter (fun k -> k >= ind) 
          |> Seq.toList 
          |> List.iter (_done.Remove >> ignore) 
          backlinks.Keys 
          |> Seq.filter (fun k -> k >= ind) 
          |> Seq.toList 
          |> List.iter (backlinks.Remove >> ignore) 
          popped.Keys 
          |> Seq.filter (fun k -> k >= ind) 
          |> Seq.toList 
          |> List.iter (popped.Remove >> ignore) 
          saved.Keys
          |> Seq.filter (fun r -> r.Tail >= ind)
          |> Seq.toList 
          |> List.iter (saved.Remove >> ignore) 
  
      // L_0
      member this.Run () : unit =
          while (hasNext() && not stopped) do
              step()
              
      member this.Add (p: GParser<'a>, s: StreamIndex) (f: GParserResult<'a> -> unit) : unit = 
  
negative.code:     inherit Parser<'a, 'r> ()
      
      override this.Apply (inp: InputStream<'a>) = 
          let t = Trampoline<'a>.New(inp)
  
          let (successes, failures) = new RSet<'a>(), new RSet<'a>()
          
  