anchor.diff:  
               this.FilterChildren handleChildren
   
  -    member this.FindNonterminalsByInd nonterminal (leftSide : array<int>) =
  -        order |> Array.filter (fun x -> nonterminal = leftSide.[x.first.prod])
  -
  -    member this.FindNonterminalsByString nonterminal (leftSide : array<int>) (numToString : int -> string) =
  -        let nontermInd = leftSide |> Array.tryFind (fun x -> String.Equals (numToString x, nonterminal))
  +    member this.FindNonterminalsByInd nonterminal =
  +        order |> Array.filter (checkAstIsGivenNonterminal nonterminal)
  +
  +    member this.FindNonterminalsByString nonterminal =
  +        let nontermInd = getNonterminalIndex nonterminal
           match nontermInd with
  -        | Some n -> this.FindNonterminalsByInd n leftSide
  +        | Some n -> this.FindNonterminalsByInd n
           | None -> [||]
      
  -    member this.GetTypeOfExpression nonterminals (leftSide : array<int>) (numToString : int -> string) =
  +    member this.GetTypeOfExpression nonterminals =
           let visited = new Dictionary<_,_>()
           let nonterminalsInd = 
               nonterminals 
  -            |> Array.map (fun n -> leftSide |> Array.find (fun x -> String.Equals (numToString x, n)))
  +            |> Array.choose getNonterminalIndex
           
           let isWanted (f : Family) =
  -            Array.exists (fun x -> x = leftSide.[f.prod]) nonterminalsInd
  +            Array.exists (fun x -> checkFamilyIsGivenNonterminal x f) nonterminalsInd
           
           let rec find (node : AstNode) = 
               if not <| visited.ContainsKey(node)
  
positive.code: 
          find root
  
      member this.CalculateStatistics nonterminal (leftSide : array<int>) (numToString : int -> string) =
          let remembered = new Dictionary<AstNode, (int * int * double) option>()
  
          let nontermInd =
              leftSide |> Array.find (fun x -> String.Equals (numToString x, nonterminal))
  
          let calculateStat (arr : ((int * int * double) option)[]) =
              let filtered = arr |> Array.filter (fun x -> x.IsSome)
  
              if filtered.Length = 0
              then None
              elif filtered.Length = 1
              then filtered.[0]
              else
                  let curMax = ref System.Int32.MinValue
                  let curMin = ref System.Int32.MaxValue
                  let curSum = ref 0.0
  
                  for a in filtered do
                      match a with 
                      | Some (max, min, ave) -> 
                          if max > !curMax then curMax := max
                          if min < !curMin then curMin := min
                          curSum := !curSum + ave
                      | None -> failwith "Seems that Array.filter does not work"
                  Some (!curMax, !curMin, (!curSum / double filtered.Length))
  
          let rec count (node : AstNode) : (int * int * double) option = 
  
negative.code: type ErrorDictionary<'TokenType> = Dictionary<Family, ErrorNode<'TokenType>>
  
  [<AllowNullLiteral>]
  type Tree<'TokenType> (tokens : array<'TokenType>, root : AstNode, rules : int[][], leftSide : array<int> option, numToString : (int -> string) option) =
      let rootFamily, isEpsilonTree =
          match root with
          | :? AST as ast -> ast, false
  