anchor.diff:          | Production(nt,fa) -> iterFA fa f edgeFilter fa.Start.Value
                   
       let reachable = 
  -        productionIndexator
  -            (fun fa n ->
  -                let buf = ref []
  -                let egf = (fun (eg:QuickGraph.TaggedEdge<_,_>) -> fst eg.Tag <> Dummy)
  -                fun x -> 
  -                    iterFA fa 
  -                        (fun eg ->
  -                            match fst eg.Tag with
  -                            | Dummy -> ()
  -                            | _ -> 
  -                                buf :=
  -                                    if eg.Source<>n
  -                                    then                                
  -                                        match fst eg.Tag with 
  -                                        | Terminal x     -> termTab.ToIndex x |> PTerminal 
  -                                        | NonTerminal x  -> ntTab.ToIndex x |> PNonTerminal
  -                                        | Dummy          -> failwith "Seems edge filter is incorrect."
  -                                        ::!buf
  -                                    else !buf ) 
  -                        egf n
  -                    n,!buf)
  -            id
  +        prodsWithIdxs
  +        |> List.map 
  +            (function 
  +             | i,Production(nt,fa) ->                
  +                fa.Vertices
  +                |> List.ofSeq
  +                |> List.map
  +                    (fun n ->
  +                        let visited = ref []
  +                        let rec step v =
  +                            if List.exists((=)v) !visited |> not
  +                            then 
  +                                visited := v :: !visited
  +                                let subRes = 
  +                                    fa.OutEdges(v)
  +                                    |> List.ofSeq
  +                                    |> List.choose
  +                                        (fun eg ->
  +                                            match fst eg.Tag with 
  +                                            | Terminal x     -> 
  +                                                let elt = termTab.ToIndex x |> PTerminal
  +                                                Some (elt,step eg.Target)
  +                                            | NonTerminal x  -> 
  +                                                let elt = ntTab.ToIndex x |> PNonTerminal
  +                                                Some (elt,step eg.Target)
  +                                            | Dummy          -> None)
  +                                List.map 
  +                                    (fun (x,l) -> if List.isEmpty l then [[x]] else List.map (fun y -> x::y) l)
  +                                    subRes
  +                                |> List.concat
  +                            else [[]]
  +                        n, step n
  +                    )
  +                |> CreateDictionary
  +                |> idx i)
  +        |> CreateDictionary
  +//        productionIndexator
  +//            (fun fa n ->
  +//                let buf = ref []
  +//                let egf = (fun (eg:QuickGraph.TaggedEdge<_,_>) -> fst eg.Tag <> Dummy)
  +//                fun x -> 
  +//                    iterFA fa 
  +//                        (fun eg ->
  +//                            match fst eg.Tag with
  +//                            | Dummy -> ()
  +//                            | _ -> 
  +//                                buf :=
  +//                                    if eg.Source<>n
  +//                                    then                                
  +//                                        match fst eg.Tag with 
  +//                                        | Terminal x     -> termTab.ToIndex x |> PTerminal 
  +//                                        | NonTerminal x  -> ntTab.ToIndex x |> PNonTerminal
  +//                                        | Dummy          -> failwith "Seems edge filter is incorrect."
  +//                                        ::!buf
  +//                                    else !buf ) 
  +//                        egf n
  +//                    n,!buf)
  +//            id
           
       member prodTab.StartID(i) = startIdx.[i].Value
       member prodTab.NonTerminal(i) = b.[i]    
  
positive.code:             (function 
               | i,Production(nt,fa) ->                
                  fa.Vertices
                  |> Seq.map 
                      (fun n ->
                         fa.OutEdges n
                         |> f fa n)
  
negative.code:                         |> Seq.iter 
                              (function
                               | Some(PNonTerminal ntB) -> 
                                   let firstSet = 
                                      let r = reachable item0
                                      r
                                      |> List.map (fun lst -> ComputeFirstSetOfTokenList (lst,pretoken))
                                      |> Set.unionMany
                                      |> Set.ofSeq                                    
                                   for prodIdx in prodTab.Productions.[ntB] do
                                       addToWorkList (prodIdx_to_item0 prodIdx,firstSet)
                               | Some(PTerminal _)|None -> ())))
  