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:         )
      //interface IComparable with
          //member x.CompareTo y = compare (x.GetHashCode()) (y.GetHashCode())
  and Trampoline<'a>(initStream: InputStream<'a>) as tram =
      let mutable stream = initStream
      let _pastEnd = new HashSet<GParser<'a> * Continuation<'a> >()
      // R
      let postrace = new ResizeArray<string>()
      let _queue = new ResizeArray<GParser<'a> * StreamIndex>()
  
      // U_j
      let _done = new Dictionary<StreamIndex, HashSet<GParser<'a> > >()
  
      // P
      let popped = new Dictionary<StreamIndex, HOMap<GParser<'a>, SSet<'a> > >()
  
      // GSS back edges
      let backlinks = new Dictionary<StreamIndex, HOMap<GParser<'a>, FSet<'a> > >()
  
      // prevents divergence in cyclic GSS traversal
      let saved = new HOMap<GParserResult<'a>, FSet<'a> >()
  
      let mutable stopped = false
      let hasNext() = _queue.Count > 0
  
      let remove() = 
          let ind = _queue.Count - 1
  
negative.code: //        else 
          p.Chain (tram, s) cont
          
  
      static member New<'a>(s) = 
          new Trampoline<'a>(s,  
                         _done = new ResizeArray<HashSet<GParser<'a> > >(), // U_j
                         popped = new ResizeArray<HOMap<GParser<'a>, SSet<'a> > >(), // P
                         backlinks = new ResizeArray<HOMap<GParser<'a>, FSet<'a> > >(), // GSS back edges
                         saved = new HOMap<GParserResult<'a>, FSet<'a> >() // prevents divergence in cyclic GSS traversal
                         )
      
      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.Queue = _queue
      member this.PastEnd : HashSet<GParser<'a> * Continuation<'a> > = _pastEnd
  
      member this.ContinuedAt (newTail: InputStream<'a>) : Trampoline<'a> = 
          let ind = stream.End
          new Trampoline<'a>(stream.Extend(newTail), 
                             new ResizeArray<_>(_done), 
                             new ResizeArray<_>(popped), 
                             new ResizeArray<_>(backlinks), 
                             new Dictionary<_,_>(saved |> Seq.map (fun v -> (v.Key, v.Value)) |> dict))
  
      // L_0
      member this.Run () : unit =
          while (_queue.Count > 0) do
              step()
              
      member this.Add (p: GParser<'a>, s: StreamIndex) (f: GParserResult<'a> -> unit) : unit = 
  