anchor.diff:  
                   let rec walk remainLength (vertex : Vertex) path =
                       if remainLength = 0 then handlePath path vertex
  -                    else
  +                    elif vertex <> null
  +                    then
                           if vertex.Level <> num then
                               if vertex.OutEdges.other <> null then
                                   vertex.OutEdges.other |> Array.iter
  
positive.code:             !expected
          
          /// returns  array that consists of tokens or error non-teminal (and its children)
          let rec astToTokens (x : obj) =
              let mutable res = []
              match x : obj with 
              | :? int as t when t >= 0 -> res <- x :: res
              | :? Family as fam ->
                  for i = 0 to fam.nodes.Length - 1 do
                      res <- res @ astToTokens fam.nodes.[i]
              | :? AST as ast ->
                  if ast.other <> null 
                  then
                      for family in ast.other do
                          if family.prod = parserSource.LeftSide.Length
                          then res <- res @ [ast]
                          else res <- res @ astToTokens family
                              
                  if ast.first.prod = parserSource.LeftSide.Length
                  then res <- [ast] @ res
                  else res <- astToTokens ast.first @ res
              | _ -> ()
              res
          
          /// collects info about error that is needed in the translation
          let createErrorNode (errFamily : Family) (errOn : obj) (prod : int) (expected : int[]) (recToks : int[]) = 
  
negative.code: 
          ignore <| addVertex startState 0 None
          let inline trd (_,_,x) = x
          let makeReductions num recovery =
              while reductions.Count > 0 do
                  let vertex, prod, pos, edgeOpt = reductions.Pop()
                  let nonTerm = parserSource.LeftSide.[prod]
  
                  let handlePath (path : obj[]) (final : Vertex) =
                      if final = null
                      then recovery()//pushes.Clear()
                      else
                          let state = parserSource.Gotos.[final.State].[nonTerm]
                          let newVertex = addVertex state num None
  