anchor.diff:      
       {NewUpdOk, NewUpdFail, NewRegenOk, NewRegenFail, NewFBItems} =
           integrate_update_key_entry_ack(
  -          NewEntryList, UpdOk, UpdFail, RegenOk, RegenFail, MissingOnOther, MyIKvTree,
  +          NewEntryList, UpdOk, UpdFail, RegenOk, RegenFail, MissingOnOther, MyIOtherKvTree,
             FBDest =/= undefined),
       
       NewStats = Stats#resolve_stats{update_count     = NewUpdOk + 1,
                                      regen_count      = NewRegenOk +1,
                                      upd_fail_count   = NewUpdFail + 1,
                                      regen_fail_count = NewRegenFail + 1},
  -    NewState = State#rr_resolve_state{stats = NewStats, feedbackKvv = {NewFBItems, MyIKvTree}},
  +    NewState = State#rr_resolve_state{stats = NewStats, feedbackKvv = {NewFBItems, MyIOtherKvTree}},
       ?ASSERT(_Diff =:= (NewRegenOk + NewUpdOk + NewUpdFail + NewRegenFail)),
       ?TRACE("UPDATED = ~p - Regen=~p", [NewUpdOk, NewRegenOk], State),
       shutdown(resolve_ok, NewState);
  
positive.code: on({get_state_response, MyI}, State =
         #rr_resolve_state{ operation = {?key_upd, KvvList, ReqKeys},
                            dhtNodePid = DhtPid, stats = _Stats }) ->
      MyIKvvList = map_kvv_list(KvvList, MyI),
      ?TRACE("GET INTERVAL - Operation=~p~n SessionId:~p~n MyInterval=~p~n KVVListLen=~p",
             [key_upd, _Stats#resolve_stats.session_id, MyI, length(KvvList)], State),
      
  
negative.code:                           my_range = MyI,
                            dhtNodePid = DhtPid,
                            stats = Stats }) ->
      MyIOtherKvvList = map_kvv_list(KvvList, MyI),
      ToUpdate = start_update_key_entry(MyIOtherKvvList, comm:this(), DhtPid),
      ?TRACE("GET ENTRIES - Operation=~p~n SessionId:~p - #Items: ~p, KVVListLen=~p ; ToUpdate=~p",
             [interval_upd, Stats#resolve_stats.session_id, length(EntryList), length(KvvList), ToUpdate], State),
      
      % Send entries in sender interval but not in sent KvvList
      % convert keys KvvList to a gb_tree for faster access checks
      MyIOtherKvTree = lists:foldl(fun({KeyX, _ValX, VersionX}, TreeX) ->
                                           % assume, KVs at the same node are equal
                                           gb_trees:enter(KeyX, VersionX, TreeX)
                                   end, gb_trees:empty(), MyIOtherKvvList),
      MissingOnOther = [entry_to_kvv(X) || X <- EntryList,
                                           not gb_trees:is_defined(db_entry:get_key(X), MyIOtherKvTree)],
      
      % allow the garbage collection to clean up the KvvList here:
      NewState = State#rr_resolve_state{operation = {?interval_upd, I, []},
                                        stats = Stats#resolve_stats{diff_size = ToUpdate},
                                        feedbackKvv = {MissingOnOther, MyIOtherKvTree}},
      if ToUpdate =:= 0 ->
             shutdown(resolve_ok, NewState);
         true ->
  