anchor.diff:              !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
  +        let astToTokens (x : obj) =            
  +            let visited = ref 0
  +            let rec go (x : obj) =
  +                let mutable res = []
  +                incr visited
  +                if !visited < 100 
  +                then                    
  +                    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 @ go 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 @ go family
                               
  -                if ast.first.prod = parserSource.LeftSide.Length
  -                then res <- [ast] @ res
  -                else res <- astToTokens ast.first @ res
  -            | _ -> ()
  -            res
  +                        if ast.first.prod = parserSource.LeftSide.Length
  +                        then res <- [ast] @ res
  +                        else res <- go ast.first @ res
  +                    | _ -> ()
  +                res
  +            go x
           
           /// collects info about error that is needed in the translation
           let createErrorNode (errFamily : Family) (errOn : obj) (prod : int) (expected : int[]) (recToks : int[]) = 
  
positive.code: 
                  let rec walk remainLength (vertex : Vertex) path =
                      if remainLength = 0 then handlePath path vertex
                      else
                          if vertex.Level <> num then
                              if vertex.OutEdges.other <> null then
                                  vertex.OutEdges.other |> Array.iter
  
negative.code:                                 while j < edges.Count && trd edges.[j] = a do
                                      j <- j + 1
                                  i <- j
                      else recovery() //pushes.Clear()
                  if pos = 0 then
                      let state = parserSource.Gotos.[vertex.State].[nonTerm]
                      let newVertex = addVertex state num None
  