anchor.diff:          | :? Epsilon as e -> Unchecked.defaultof<_>, true
           | _ -> failwith "Strange tree - consists of terminal"
       let order =
  -        let stack = new System.Collections.Generic.Stack<_>()
  +        let stack = new Stack<_>()
           match root with
           | :? AST as ast -> stack.Push ast
           | _ -> ()
  
positive.code:                     let res = filter ast.first
                      if res then forestFam := ast.first :: !forestFam
                      res
                  | _ -> failwith "Error in GetForestWithToken function"
  
              let mutable tree = fst <| this.GetNextTree [token] filter
  
  
negative.code:                     res.Add (ranges.[i], Array.append [|children.first.prod|] (children.other |> Array.map (fun family -> family.prod)))
          res
  
      static member FamilyToTokens = Dictionary<Family, Terminal list>()
      static member GetTokensFromFamily (family : Family) : Terminal list = 
          let cache = Tree<_>.FamilyToTokens
          // for avoiding problems with cycles
          let remembered = new ResizeArray<_>()
  
          let rec familyToTokens family = 
              
              let nodeToTokens (node : obj) = 
                  match node with
                  | :? Terminal as t -> [t]
                  | :? Epsilon -> []
                  | :? AST as ast -> 
                      if ast.other <> null
                      then 
                          ast.other
                          |> Array.map (fun fam -> familyToTokens family)
                          |> List.concat
                          |> List.append (familyToTokens ast.first)
                      else
                          familyToTokens ast.first
                  | x -> failwithf "Unexpected node type in AST: %s" <| x.GetType().ToString()
                  
              if remembered.Contains family
              then 
                  []
              else
                  remembered.Add family
                  let toks = 
                      family.nodes.map(fun node -> nodeToTokens node)
                      |> List.concat
              
                  ignore <| remembered.Remove family
                  toks
  
          if not <| cache.ContainsKey family
          then 
              let res = familyToTokens family
              cache.[family] <- res
          cache.[family]
  
      member private this.getTokensFromFamilyAsTokenTypes (family : Family) = 
          Tree<_>.GetTokensFromFamily family 
          |> List.map (fun t -> tokens.[t.TokenNumber]) 
          |> List.toArray
  
      member this.collectErrors tokenToRange = 
          let res = new ResizeArray<'Position * 'Position * array<'TokenType>>()
  