anchor.diff:  
   module Yard.Generators.Common.AST
   open System
  +open System.IO
   open System.Collections.Generic
   open Yard.Generators.Common.DataStructures
   open Yard.Generators.Common.AstNode
  
positive.code:                     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 
  
negative.code:             |> Array.fold (fun acc elem -> processElem elem acc) []
  
          // now parameter 'tokens' is all sppf tokens rather than tokens from new tree
          let newTree = new Tree<_>(tokens, tree, rules)
          newTree, finalUnprocessed
  
      ///<summary>
      /// Returns all trees that contain some token.
      /// <para> tokRange - range of token </para>
      /// <para> tokenToRange - mapping from token to range </para>
      ///</summary>
      member this.GetForestWithToken tokRange (tokenToRange: 'TokenType -> seq<_>) = 
          let tryFindToken() = 
              let predicate tok = 
                  let range = tokenToRange tok
                  tokRange = Seq.head range
              tokens
              |> Array.tryFindIndex predicate
  
          let tokNumberOption = tryFindToken()
          match tokNumberOption with
          | None -> []
          | Some tokNumber ->
              let token = new Terminal(tokNumber)
              let forestFam = ref []
              let mutable forestTree = []
              let filterFamily family = 
                  let nodes = Tree<_>.GetTokensFromFamily family
                  if nodes |> List.exists ((=) token) 
                  then 
                      !forestFam 
                      |> List.forall (fun fam -> 
                                          let famNodes = Tree<_>.GetTokensFromFamily fam
                                          let newList = List.filter (fun node1 -> List.exists ((=) node1) famNodes) nodes
                                          newList.Length = nodes.Length
                                      ) 
                  else false
  
              let filterTree (tree : Tree<_>) = 
                  match tree.Root with
                  | :? AST as ast -> 
                      // I suppose that rootFamily.other is always null. But I'm not sure
                      let res = filterFamily ast.first
                      if res then forestFam := ast.first :: !forestFam
                      res
                  | x -> failwithf "Error in GetForestWithToken function. Expected AST as tree.Root but %A was" <| x.GetType()
  
              let mutable tree = fst <| this.GetNextTree [token] filterFamily
              while filterTree tree do
                  forestTree <- tree :: forestTree
                  tree <- fst <| this.GetNextTree [token] filterFamily
          
              forestTree
  
  