anchor.diff:  -spec adjacent_succ(rt_entry()) -> key().
   adjacent_succ(#rt_entry{adjacent_fingers={_Pred,Succ}}) -> Succ.
   
  +%% @doc Set the adjacent fingers of a node
  +-spec set_adjacent_fingers(rt_entry(), key(), key()) -> rt_entry().
  +set_adjacent_fingers(#rt_entry{} = Entry, PredId, SuccId) ->
  +    Entry#rt_entry{adjacent_fingers={PredId, SuccId}}.
  +
   %% @doc Set the adjacent successor of the finger
   -spec set_adjacent_succ(rt_entry(), key()) -> rt_entry().
   set_adjacent_succ(#rt_entry{adjacent_fingers={PredId, _Succ}} = Entry, SuccId) ->
  -    Entry#rt_entry{adjacent_fingers={PredId, SuccId}}.
  +    set_adjacent_fingers(Entry, PredId, SuccId).
   
   %% @doc Set the adjacent predecessor of the finger
   -spec set_adjacent_pred(rt_entry(), key()) -> rt_entry().
   set_adjacent_pred(#rt_entry{adjacent_fingers={_Pred, SuccId}} = Entry, PredId) ->
  -    Entry#rt_entry{adjacent_fingers={PredId, SuccId}}.
  +    set_adjacent_fingers(Entry, PredId, SuccId).
   
   %% @doc Get the adjacent predecessor rt_entry() of the given node.
   -spec predecessor_node(RT :: rt(), Node :: rt_entry()) -> rt_entry().
  
positive.code:     %% merge the routing tables. Note: We don't care if this message is not from our
      %current successor. We just have to make sure that the merged entries are valid.
      LocalRT = rt_loop:get_rt(State),
      NewRT = case LocalRT =:= RT of
          true ->
              % - add each entry from the other RT if it doesn't already exist
              % - entries to be added have to be normal entries
              util:gb_trees_foldl(
                  fun(Key, Entry, Acc) ->
                          %% TODO send an async message to check if entry is valid; if it
  
negative.code:         true -> ok;
          _Else -> % update the exported routing table
              Pid = pid_groups:get_my(dht_node),
              case Pid of
                  failed -> ok;
                  _E     -> RTExt = export_rt_to_dht_node(NewRT, NewNeighbors),
  