anchor.diff:              (function 
                | i,Production(nt,fa) ->                
                   fa.Vertices
  -                |> Seq.map 
  +                |> List.ofSeq
  +                |> List.map 
                       (fun n ->
                          fa.OutEdges n
                          |> f fa n)
  
positive.code:         | 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
          
      member prodTab.StartID(i) = startIdx.[i].Value
      member prodTab.NonTerminal(i) = b.[i]    
  
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 -> ())))
  