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:                         false
  
                  | false -> false
      
          let t = p.topState
          let R = new HashSet<AbstractStack>()
  
          match isReadyForReduce t p with
              | true ->      
                  let n = tables.reductionSymbolCount t
                  for i in [1..n] 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
  
negative.code:                 result
           
              | false -> 
                 // printfn "Curr - %A" state 
                 // p.print
                 // printfn "\n"
                  let result = new HashSet<AbstractStack>()
                  result.Add p |> ignore
                  result
       
      let rec compute (c:Call<_>) state (X:Expression<_>) =
          match X with 
          | Var(a) -> 
              let CurFlowEq = FlowExpression(a, flowEquations.[a])
              if not (findCallInGraph F (Call(CurFlowEq, state)) c) then 
                  F.AddVerticesAndEdge(Edge(Call(CurFlowEq, state), c)) |> ignore
              if not(Cache.ContainsKey(Call(CurFlowEq, state))) then
                  let temp = new HashSet<AbstractStack>()
                  Cache.Add(Call(CurFlowEq, state), temp)
                  W.Add(Call(CurFlowEq, state)) |> ignore
              if findCallInGraph F c (Call(CurFlowEq, state)) then 
                  let t = Cache.[Call(CurFlowEq, state)]
                  let Result = new HashSet<AbstractStack>()
                  for e in t do
                      e.fold
                      Result.Add e |> ignore
                     
                  Result
              else 
                  let Result = new HashSet<AbstractStack>()
                  Result.UnionWith Cache.[Call(CurFlowEq, state)] |> ignore
                  Result
          | Value(t) -> 
              reduce state (AbstractStack(tables.gotoTerminal state t))
          | Union(E1,E2) -> 
             let res = (compute c state E1)
             res.UnionWith(compute c state E2)
             res
          | Concat(E1, E2) ->
              let P = new HashSet<AbstractStack>()
             
  