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: shutdown(_Reason, #rr_resolve_state{ownerPid = Owner, send_stats = SendStats,
                                      stats = #resolve_stats{resolve_started = ResStarted0} = Stats,
                                      operation = _Op, feedbackDestPid = FBDest,
                                      feedbackKvv = {FbKVV, _MyIKvTree},
                                      from_my_node = FromMyNode} = _State) ->
      ?TRACE("SHUTDOWN ~p - Operation=~p~n SessionId:~p~n ~p items via key_upd to ~p~n Items: ~.2p",
             [_Reason, util:extint2atom(element(1, _Op)), Stats#resolve_stats.session_id,
  
negative.code:     NewState = State#rr_resolve_state{operation = {?key_upd, [], []},
                                        stats = Stats#resolve_stats{diff_size = ToUpdate},
                                        feedbackKvv = {lists:append(FbKVV, KvvList),
                                                       MyIOtherKvTree}},
      
      if ToUpdate =:= 0 ->
             % use the same options as above in get_state_response:
  