anchor.diff:                      let inline handleAst (ast : obj) =
                           match ast with
                           | :? OtherAST as ast ->
  -                            if ast.pos = -1 then
  -                                stack.Push ast
  +                            if ast.pos = -1 
  +                            then stack.Push ast
                           | _ -> ()
                       family.nodes.doForAllRev handleAst
                   handle children.first
  -                if children.other <> null then
  -                    for family in children.other do
  -                        handle family
  +                if children.other <> null 
  +                then children.other |> Array.iter (fun family -> handle family)
           res.ToArray()
   
       let familyToTokens = 
           let dict = new Dictionary<OtherFamily, int list>()
           // to avoid problems with cycles
  -        let processedAst = new ResizeArray<OtherAST>()
  +        let processedAst = new ResizeArray<_>()
   
           let rec calcTokens (family : OtherFamily) = 
               if dict.ContainsKey family 
  
positive.code: ﻿module Yard.Generators.RNGLR.OtherSPPF
  
  open System.Collections.Generic
  open Yard.Generators.Common.AST
  open Yard.Generators.Common.AstNode
  open Yard.Generators.Common.DataStructures
  
negative.code:                 dict.[family]
              else
                  let tokens = ref []
  
                  let processNode (node : obj) = 
                      match node with
                      | :? OtherAST as ast -> 
                          if not <| processedAst.Contains ast
                          then
                              processedAst.Add ast
  
                              let temp = 
                                  if ast.other = null 
                                  then 
                                      calcTokens ast.first 
                                  else
                                      ast.other
                                      |> Array.map (fun fam -> calcTokens fam)
                                      |> Array.append [| calcTokens ast.first |]
                                      |> List.concat
                              tokens := !tokens @ temp
                              processedAst.Remove ast |> ignore
                      | :? Terminal as t ->
                          tokens := t.TokenNumber :: !tokens
                      | _ -> ()
  
  
                  family.nodes.doForAll (fun node -> processNode node)
                  
                  dict.Add (family, !tokens)
                  
  