anchor.diff:         true ->
              % note: shutdown and feedback handled by update_key_entry_ack
              NewState#rr_resolve_state{feedbackKvv =
  -                                      {lists:append(FbKVV, KvvList), MyIKvTree}}
  +                                      {lists:append(FbKVV, KvvList), MyIOtherKvTree}}
       end;
   
   on({get_state_response, MyI}, State =
          #rr_resolve_state{ operation = {?key_upd2, KvList, DestPid},
                             dhtNodePid = DhtPid, stats = Stats }) ->
  -    MyIKvList = map_kvv_list(KvList, MyI),
  +    MyIOtherKvList = map_kvv_list(KvList, MyI),
       ?TRACE("GET INTERVAL - Operation=~p~n SessionId:~p~n MyInterval=~p~n KVListLen=~p",
              [key_upd2, Stats#resolve_stats.session_id, MyI, length(KvList)], State),
       
       % get local entries for comparison
  -    RepKeyInt = intervals:from_elements([KeyX || {KeyX, _VerX} <- MyIKvList]),
  +    RepKeyInt = intervals:from_elements([KeyX || {KeyX, _VerX} <- MyIOtherKvList]),
       comm:send_local(DhtPid,
                  {get_chunk, self(), RepKeyInt, fun rr_recon:get_chunk_filter/1,
                   fun rr_recon:get_chunk_kvv/1, all}),
       
       % convert keys KvvList to a gb_tree for faster access checks
  -    MyIKvTree = lists:foldl(fun({KeyX, VersionX}, TreeX) ->
  -                                    % assume, KVs at the same node are equal
  -                                    gb_trees:enter(KeyX, VersionX, TreeX)
  -                            end, gb_trees:empty(), MyIKvList),
  +    MyIOtherKvTree = lists:foldl(fun({KeyX, VersionX}, TreeX) ->
  +                                         % assume, KVs at the same node are equal
  +                                         gb_trees:enter(KeyX, VersionX, TreeX)
  +                                 end, gb_trees:empty(), MyIOtherKvList),
       
       % allow the garbage collection to clean up the KvvList and ReqKeys here:
       State#rr_resolve_state{operation = {?key_upd2, [], DestPid},
  -                           stats = Stats#resolve_stats{diff_size = gb_trees:size(MyIKvTree)},
  -                           feedbackKvv = {[], MyIKvTree}};
  +                           stats = Stats#resolve_stats{diff_size = gb_trees:size(MyIOtherKvTree)},
  +                           feedbackKvv = {[], MyIOtherKvTree}};
   
   on({get_chunk_response, {_RestI, KvvList}}, State =
          #rr_resolve_state{ operation = {?key_upd2, [], Dest},
  -                          feedbackKvv = {[], MyIKvTree},
  +                          feedbackKvv = {[], MyIOtherKvTree},
                             from_my_node = FromMyNode, stats = Stats}) ->
       ?ASSERT(State#rr_resolve_state.feedbackDestPid =:= undefined),
       ?ASSERT(intervals:is_empty(_RestI)),
  
positive.code:     
      {NewUpdOk, NewUpdFail, NewRegenOk, NewRegenFail, NewFBItems} =
          integrate_update_key_entry_ack(
            NewEntryList, UpdOk, UpdFail, RegenOk, RegenFail, MissingOnOther, MyIKvTree,
            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}},
      ?ASSERT(_Diff =:= (NewRegenOk + NewUpdOk + NewUpdFail + NewRegenFail)),
      ?TRACE("UPDATED = ~p - Regen=~p", [NewUpdOk, NewRegenOk], State),
      shutdown(resolve_ok, NewState);
  
negative.code: on({get_state_response, MyI}, State =
         #rr_resolve_state{ operation = {?key_upd, KvvList, ReqKeys},
                            dhtNodePid = DhtPid, stats = _Stats }) ->
      MyIOtherKvvList = 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),
      
  