anchor.diff:              let part = new GPartial<'a, 'r>(new PartialParser<'a, 'r>(t, successes, failures)) :> GParserResult<'a>
               part :: (successes |> Seq.toList)
           else (if successes.Count = 0 then failures else successes) |> Seq.toList
  -
  -and PartialParser<'a, 'r when 'r : equality> (t: Trampoline<'a>, successes: HashSet<GParserResult<'a> >, failures: HashSet<GParserResult<'a> >) = 
  +// Implemented with shallow copying trampoline
  +and PartialParser<'a, 'r when 'r : equality> (oldT: Trampoline<'a>, successes: HashSet<GParserResult<'a> >, failures: HashSet<GParserResult<'a> >) = 
       inherit Parser<'a, 'r> ()
  -    let stream: InputStream<'a> = t.Stream
  -    let _pastEnd = new HashSet<_>(t.PastEnd |> Seq.map id)
  +    let stream: InputStream<'a> = oldT.Stream
  +    let _pastEnd = new HashSet<_>(oldT.PastEnd |> Seq.map id)
       override this.Apply(inp: InputStream<'a>) = 
           let ind = stream.End
   
  -        t.PrepareReparse(ind + 1)
  +        let t = oldT.ContinuedAt(inp)
   
           t.Stream <- stream.Extend(inp)
           for (p, f) in _pastEnd do
  -            p.Chain(t, ind) f
  -            //t.Add (p, s) f
  +            //p.Chain(t, ind) f
  +            t.Add (p, ind) f
           t.Run()
           if t.PastEnd.Count > 0 then 
               let part = new GPartial<'a, 'r>(new PartialParser<'a, 'r>(t, successes, failures)) :> GParserResult<'a>
  
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:         let p, s = remove()
          //postrace.Add(sprintf "%d %A" s.Ind p)
          let cont = fun (res: GParserResult<'a>) ->
              while popped.Count <= s do popped.Add(null)
              if popped.[s] <> null then
                  let parsers = popped.[s]
                  if not <| parsers.ContainsKey(p) then
                      parsers.Add(p, new SSet<'a>() )
              else
                  let nmap = new HOMap<GParser<'a>, SSet<'a> >() in nmap.Add(p, new SSet<'a>() )
                  popped.[s] <- nmap
  
              if res.Succeeded then
                  popped.[s].[p].Add(res) |> ignore
  