anchor.diff:                                      f nodes.other.[i]
                                   needDo <- needDo || nodes.other.[i] = nd
   
  -            /// applies function to nodes which are located to the left than node nd. 
  +            /// <summary>
  +            /// applies function f to nodes which are located to the left than node nd. 
               /// Left sibling of nd is first.
  +            /// </summary>
  +            /// <param name="nd"></param>
  +            /// <param name="f"></param>
               member nodes.doForAllBeforeNode nd f = 
                   if nodes.fst <> null && nodes.fst <> nd
                   then 
  
positive.code:                                 for fam in ast.other do
                                      temp := !temp @ calcTokens fam
                              tokens := !tokens @ !temp
  
                      | :? int as t when t >= 0 ->
                          tokens := t :: !tokens
                      | _ -> ()
                  )
                  
                  dict.Add (family, !tokens)
                  !tokens
  
          calcTokens root.first |> ignore
          dict
  
      let findLeaves (now : 'range) (tokenToPos : 'TokenType -> seq<'range>)= 
          let leaf = ref []
          let nd = ref null
  
          let containsRange number = 
              tokenToPos tokens.[number]
  
negative.code:                         else false
                  else false
              
              /// <summary>
              /// applies function to nodes which are located to the right than node nd. 
              /// Right sibling of nd is first.
              /// </summary>
              /// <param name="nd"></param>
              /// <param name="f"></param>
              member nodes.doForAllAfterNode nd f =
                  let mutable needDo = false
                  if nodes.fst <> null 
  