anchor.diff:      
               
               
  -
       let checkResult = 
           let mutable flag = true
           if Cache.ContainsKey(X0) then
               for e in Cache.[X0] do
  -               
  +               //printfn "%A" e.topState
                  if not (tables.isAccept e.topState) then
                      flag <- false
           flag
  -    
  +   
       match checkResult with
           |true -> Accept
           |false -> Error
  -
       
  -(*let FlowEquations1 =  new Dictionary<string, Expression<ParserLAR.token>>()
  -
  -FlowEquations1.Add("X0", Value(ParserLAR.A)) |> ignore
  -FlowEquations1.Add("R" , Value(ParserLAR.R)) |> ignore  
  -FlowEquations1.Add("X1", Var("X0") ++ Var("X2")) |> ignore   
  -FlowEquations1.Add("X2", Value(ParserLAR.L) +. (Var("X1") +. Var("R"))) |> ignore   
  -FlowEquations1.Add("X3", Var("X1")) |> ignore
  -
  -let x0 =  Call(FlowExpression("X3", FlowEquations1.["X3"]), 0)
  -printfn "%A" (algo x0 FlowEquations1 (CleverParseTable<ParserLAR.token>(ParserLAR.tables())))
  -
  -
  -let FlowEquations2 =  new Dictionary<string, Expression<ParserAR.token>>()
  -
  -FlowEquations2.Add("X0", Value(ParserAR.A)) |> ignore
  -FlowEquations2.Add("R" , Value(ParserAR.R)) |> ignore  
  -FlowEquations2.Add("X1", Var("X0") ++ Var("X2")) |> ignore   
  -FlowEquations2.Add("X2", (Var("X1") +. Var("R"))) |> ignore   
  -FlowEquations2.Add("X3", Var("X1")) |> ignore
  -
  -let x02 =  Call(FlowExpression("X3", FlowEquations2.["X3"]), 0)
  -printfn "%A" (algo x02 FlowEquations2 (CleverParseTable<ParserAR.token>(ParserAR.tables())))
  -
  -
  -
  -*)
  
positive.code:                        let p' = p.Clone
                         p'.top <- s'
                         poppedStack.Add(p') |> ignore
  
                     for p' in poppedStack do
                         let newGotoState = tables.gotoNonTerminal p'.topState state 
                         R.Add(p' + AbstractStack(newGotoState)) |> ignore
  
                  let result = new HashSet<AbstractStack>()
  
negative.code:                         false
  
                  | false -> false
          
          let t = p.topState
          
          let R = new HashSet<AbstractStack>()
  
          match isReadyForReduce t p with
              | true ->    
                  let n = tables.reductionSymbolCount t
                  // printfn "Reduce - %A %A" n state 
                  //p.print
                  //printfn "\n"
                  for i = 1 to n - 1 do
                    p.pop
                  
                  let nTop = p.top               
                  let newTops = p.predecessor nTop
                    
                  if newTops.Count = 0 then
                     let newGotoState = tables.gotoNonTerminal state t 
                     R.Add(AbstractStack(newGotoState)) |> ignore
  