anchor.diff:                            my_range = MyI,
                             dhtNodePid = DhtPid,
                             stats = Stats }) ->
  -    MyIKvvList = map_kvv_list(KvvList, MyI),
  -    ToUpdate = start_update_key_entry(MyIKvvList, comm:this(), DhtPid),
  +    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
  -    MyIKvTree = 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(), MyIKvvList),
  +    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), MyIKvTree)],
  +                                         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, MyIKvTree}},
  +                                      feedbackKvv = {MissingOnOther, MyIOtherKvTree}},
       if ToUpdate =:= 0 ->
              shutdown(resolve_ok, NewState);
          true ->
  
positive.code:        true ->
             % note: shutdown and feedback handled by update_key_entry_ack
             NewState#rr_resolve_state{feedbackKvv =
                                        {lists:append(FbKVV, KvvList), MyIKvTree}}
      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),
      ?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]),
      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),
      
      % 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}};
  
  on({get_chunk_response, {_RestI, KvvList}}, State =
         #rr_resolve_state{ operation = {?key_upd2, [], Dest},
                            feedbackKvv = {[], MyIKvTree},
                            from_my_node = FromMyNode, stats = Stats}) ->
      ?ASSERT(State#rr_resolve_state.feedbackDestPid =:= undefined),
      ?ASSERT(intervals:is_empty(_RestI)),
  
negative.code:                                                   regen_fail_count = RegenFail
                                                  } = Stats,
                            feedbackDestPid = FBDest,
                            feedbackKvv = {MissingOnOther, MyIOtherKvTree}
                          })
    when element(1, Op) =:= ?key_upd;
         element(1, Op) =:= ?interval_upd ->
  