anchor.diff:           operation      = undefined                               :: undefined | operation(),
            my_range       = undefined                               :: undefined | intervals:interval(),
            feedbackDestPid= undefined                               :: undefined | comm:mypid(),
  -         feedbackKvv    = {[], gb_trees:empty()}                  :: {MissingOnOther::kvv_list(), MyIKvTree::gb_tree()},
  +         feedbackKvv    = {[], gb_trees:empty()}                  :: {MissingOnOther::kvv_list(), MyIOtherKvTree::gb_tree()},
            send_stats     = undefined                               :: undefined | comm:mypid(),
            stats          = #resolve_stats{}                        :: stats(),
            from_my_node   = 1                                       :: 0 | 1
  
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:        true ->
             % note: shutdown and feedback handled by update_key_entry_ack
             NewState#rr_resolve_state{feedbackKvv =
                                        {lists:append(FbKVV, KvvList), MyIOtherKvTree}}
      end;
  
  on({get_state_response, MyI}, State =
         #rr_resolve_state{ operation = {?key_upd2, KvList, DestPid},
                            dhtNodePid = DhtPid, stats = Stats }) ->
      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} <- 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
      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(MyIOtherKvTree)},
                             feedbackKvv = {[], MyIOtherKvTree}};
  
  on({get_chunk_response, {_RestI, KvvList}}, State =
         #rr_resolve_state{ operation = {?key_upd2, [], Dest},
                            feedbackKvv = {[], MyIOtherKvTree},
                            from_my_node = FromMyNode, stats = Stats}) ->
      ?ASSERT(State#rr_resolve_state.feedbackDestPid =:= undefined),
      ?ASSERT(intervals:is_empty(_RestI)),
  