anchor.diff:              let processNode (node : obj) (newNodes : list<_> ref)= 
                   let newElem = 
                       match node with 
  -                    | :? AST as ast -> box <| processAST ast
  +                    | :? AST as ast -> 
  +                        if dict.ContainsKey ast
  +                        then box <| dict.[ast]
  +                        else box <| processAST ast
                       | :? int as token -> box token
                       | _ -> failwithf "Unexpected AST element in OtherSPPF"
                   
  
positive.code:             then family.nodes.doForAllAfterNode node f
              else family.nodes.doForAllBeforeNode node f
  
          for family in cur do
              let mutable current = box family
              let count = ref 1
  
              let rec processFamily (family : OtherFamily) = 
                  if familyToTokens.ContainsKey family && 
                      not <| List.exists (fun t -> tokenToNumber tokens.[t] = pairNumber) familyToTokens.[family]
                  then ()
                  else
                      let handle (node : obj) =
  
negative.code:                                 for fam in ast.other do
                                      temp := !temp @ calcTokens fam
                              tokens := !tokens @ !temp
                              visitingAST.Remove ast |> ignore
                      | :? int as t when t >= 0 ->
                          tokens := t :: !tokens
                      | _ -> ()
                  )
                  
                  dict.Add (family, !tokens)
                  
                  !tokens
  
          calcTokens root.first |> ignore
          dict
  
      let findNodeWithParents (now : 'range) (tokenToPos : 'TokenType -> seq<'range>)= 
          let parents = ref []
          let child = ref null
  
          let containsRange number = 
              tokenToPos tokens.[number]
  