anchor.diff:              | :? Epsilon -> Unchecked.defaultof<_>
               | _ -> failwith "Strange tree - singleNode with non-negative value"
   
  -        let dict = new System.Collections.Generic.Dictionary<AST, OtherAST>()
  +        let dict = new Dictionary<AST, OtherAST>()
           
           // to avoid problems with cycles
           let knownNodes = new ResizeArray<_>()
           
  -        let nodesDict = System.Collections.Generic.Dictionary<Nodes, OtherNodes>()
  +        let nodesDict = new Dictionary<Nodes, OtherNodes>()
           // reverse edges that will be added after all
  -        let postActions = new System.Collections.Generic.Dictionary<OtherFamily, Nodes>() 
  +        let postActions = new Dictionary<OtherFamily, Nodes>() 
           let rec processFamily (family : Family) = 
               let processAST (ast : AST) = 
                   if dict.ContainsKey ast 
  -                then dict.[ast]
  +                then 
  +                    dict.[ast]
                   else
                       let fstChild = processFamily ast.first
                       let otherChildren = 
  
positive.code:                     let inline handleAst (ast : obj) =
                          match ast with
                          | :? OtherAST as 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
          res.ToArray()
  
      let familyToTokens = 
          let dict = new Dictionary<OtherFamily, int list>()
          // to avoid problems with cycles
          let processedAst = new ResizeArray<OtherAST>()
  
          let rec calcTokens (family : OtherFamily) = 
              if dict.ContainsKey family 
  
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)
                  
  