anchor.diff:  
   let (>>=)<'a, 'r, 'r2 when 'r: equality and 'r2 : equality> (p: Parser<'a, 'r>) (fn: 'r -> Parser<'a, 'r2>) : Parser<'a, 'r2> = 
       { new NonTerminalParser<'a, 'r2>() with 
  -      override nt.Chain(t, inp) (cont) = 
  -            t.Add(p, inp) (Cont.New (fun (t, res) -> 
  +      override nt.Chain(inp: InputStream<'a>) (cont) =
  +            T.Add(p, inp) <| Cont.New (fun res ->
                   match res with 
  -                | :? GSuccess<'a, 'r> as succ1 -> fn(succ1.Value).Chain(t, succ1.Tail) (cont)
  -                | fail -> (t, fail) |> cont.F))
  +                | :? GSuccess<'a, 'r> as s1 -> fn(s1.Value).Chain(s1.Tail) (cont)
  +                | fail -> fail |> cont.F )  
       } :> Parser<'a, 'r2>
   
  -let many1<'a, 'r when 'r : equality> (this: Parser<'a, 'r>) = 
  +let many1<'a, 'r when 'r : equality> (p: Parser<'a, 'r>) = 
       { new NonTerminalParser<'a, 'r list>() with 
  -        override nt.Chain(t, inp) (f) = 
  -            t.Add(this, inp) (Cont.New (fun (t, r) -> 
  +        override q.Chain s f = 
  +            T.Add(p, s) (Cont.New (fun r -> state {
                   match r with
                   | :? GSuccess<'a, 'r> as s1 -> 
  -                    let t = (t, success<'a, 'r list> [s1.Value] s1.Tail) |> f.F
  -                    t.Add(nt, s1.Tail) (Cont.WithSucc (fun s2 -> success<'a, 'r list> (s1.Value :: s2.Value) s2.Tail) f)
  -                | fail -> (t, fail) |> f.F
  -            ))
  +                    do! success<'a, 'r list> [s1.Value] s1.Tail |> f.F
  +                    do! T.Add(q, s1.Tail) (Cont.WithSucc (fun s2 -> success<'a, 'r list> (s1.Value :: s2.Value) s2.Tail) f)
  +                | fail -> do! fail |> f.F } ) ) 
  +            
       } :> Parser<'a, 'r list>
   
  -let many<'a, 'r when 'r : equality> (this: Parser<'a, 'r>) = 
  +let many<'a, 'r when 'r : equality> (p: Parser<'a, 'r>) = 
       { new NonTerminalParser<'a, 'r list>() with 
  -        override nt.Chain (t, s) f =
  -            let t = (t, success<'a, 'r list> [] s) |> f.F
  -            t.Add(many1 this, s) f
  +        override nt.Chain s f = state {
  +            do! success<'a, 'r list> [] s |> f.F
  +            do! T.Add(many1 p, s) f }
       } :> Parser<'a, 'r list>
   
  -let opt<'a, 'r when 'r : equality> (this: Parser<'a, 'r>) = 
  +let opt<'a, 'r when 'r : equality> (p: Parser<'a, 'r>) = 
       { new NonTerminalParser<'a, 'r option>() with 
  -        override nt.Chain(t, s) (f) = 
  -            let t = (t, success<'a, 'r option> None s) |> f.F
  -            t.Add(this, s) (Cont.WithSucc (fun r -> success (Some r.Value) r.Tail) f)
  +        override nt.Chain(s) (f) : PState<'a> = state {
  +            do! (success<'a, 'r option> None s) |> f.F
  +            do! T.Add(p, s) (Cont.WithSucc (fun r -> success (Some r.Value) r.Tail) f) }
       } :> Parser<'a, 'r option>
   
   let epsilon<'a> = preturn ()
  
positive.code: open FSharpx.Prelude
  open System.Threading
  open FsGll.InputStream
  
  let msgLibraryError = "Error in FsGll library."
  let msgDummyUsed = "Parser created with createParserForwardedToRef is not defined"
  
  //let trace s = printfn "%s" s
  let trace _ = ()
  
negative.code:             | :? GSuccess<'a, 'r> as succ1 -> [succ1]
              | x -> [x]
      
      override this.Chain (inp) (f) = this.Parse inp |> f.F
  
  and DisjunctiveParser<'a, 'r when 'r : equality>(left: Parser<'a, 'r>, right: Parser<'a, 'r>) as disj =
      inherit NonTerminalParser<'a, 'r>()
  