anchor.diff:  %%      and the entry in MyEntries has a newer version than the one in the tree
   %%      and returns them as FBItems. ReqItems contains items in the tree but
   %%      where the version in MyEntries is older than the one in the tree.
  --spec get_part_diff(MyEntries::db_chunk_kv(), MyIOtherKvTree::kv_tree(),
  +-spec get_part_diff(MyEntries::db_chunk_kv(), MyIOtherKvTree::kvi_tree(),
                       AccFBItems::[?RT:key()], AccReqItems::[bitstring()],
                       SigSize::signature_size(), VSize::signature_size())
  -        -> {FBItems::[?RT:key()], ReqItems::[bitstring()], MyIOtherKvTree::kv_tree()}.
  -get_part_diff(MyEntries, MyIOtKvTree, FBItems, ReqItems, SigSize, VSize) ->
  -    get_part_diff_(MyEntries, MyIOtKvTree, FBItems, ReqItems, SigSize,
  +        -> {FBItems::[?RT:key()], ReqItemsIdx::[non_neg_integer()], MyIOtherKvTree::kvi_tree()}.
  +get_part_diff(MyEntries, MyIOtKvTree, FBItems, ReqItemsIdx, SigSize, VSize) ->
  +    get_part_diff_(MyEntries, MyIOtKvTree, FBItems, ReqItemsIdx, SigSize,
                      util:pow(2, VSize)).
   
   %% @doc Helper for get_part_diff/6.
  --spec get_part_diff_(MyEntries::db_chunk_kv(), MyIOtherKvTree::kv_tree(),
  +-spec get_part_diff_(MyEntries::db_chunk_kv(), MyIOtherKvTree::kvi_tree(),
                        AccFBItems::[?RT:key()], AccReqItems::[bitstring()],
                        SigSize::signature_size(), VMod::pos_integer())
  -        -> {FBItems::[?RT:key()], ReqItems::[bitstring()], MyIOtherKvTree::kv_tree()}.
  -get_part_diff_([], MyIOtKvTree, FBItems, ReqItems, _SigSize, _VMod) ->
  -    {FBItems, ReqItems, MyIOtKvTree};
  -get_part_diff_([{Key, Version} | Rest], MyIOtKvTree, FBItems, ReqItems, SigSize, VMod) ->
  +        -> {FBItems::[?RT:key()], ReqItemsIdx::[non_neg_integer()], MyIOtherKvTree::kvi_tree()}.
  +get_part_diff_([], MyIOtKvTree, FBItems, ReqItemsIdx, _SigSize, _VMod) ->
  +    {FBItems, ReqItemsIdx, MyIOtKvTree};
  +get_part_diff_([{Key, Version} | Rest], MyIOtKvTree, FBItems, ReqItemsIdx, SigSize, VMod) ->
       {KeyBin, VersionShort} = compress_kv_pair(Key, Version, SigSize, VMod),
       case gb_trees:lookup(KeyBin, MyIOtKvTree) of
           none ->
  -            get_part_diff_(Rest, MyIOtKvTree, FBItems, ReqItems,
  +            get_part_diff_(Rest, MyIOtKvTree, FBItems, ReqItemsIdx,
                              SigSize, VMod);
  -        {value, OtherVersionShort} ->
  +        {value, {OtherVersionShort, Idx}} ->
               MyIOtKvTree2 = gb_trees:delete(KeyBin, MyIOtKvTree),
               if VersionShort > OtherVersionShort ->
  -                   get_part_diff_(Rest, MyIOtKvTree2, [Key | FBItems], ReqItems,
  +                   get_part_diff_(Rest, MyIOtKvTree2, [Key | FBItems], ReqItemsIdx,
                                     SigSize, VMod);
                  VersionShort =:= OtherVersionShort ->
  -                   get_part_diff_(Rest, MyIOtKvTree2, FBItems, ReqItems,
  +                   get_part_diff_(Rest, MyIOtKvTree2, FBItems, ReqItemsIdx,
                                     SigSize, VMod);
                  true ->
  -                   get_part_diff_(Rest, MyIOtKvTree2, FBItems, [KeyBin | ReqItems],
  +                   get_part_diff_(Rest, MyIOtKvTree2, FBItems, [Idx | ReqItemsIdx],
                                     SigSize, VMod)
               end
       end.
  
positive.code:                            method = bloom}) ->
      ?TRACE1(_Msg, State),
      
      DBChunkTree = decompress_kv_list(DBChunk, [], SigSize, VSize),
  
      NewStats2 = shash_bloom_perform_resolve(
                    State, DBChunk, DBChunkTree, SigSize, VSize, DestReconPid, [],
                    % nothing to do if the chunk is empty
                    gb_trees:is_empty(DBChunkTree)),
      shutdown(sync_finished, State#rr_recon_state{stats = NewStats2});
  
negative.code:                end,
  
             % let the non-initiator's rr_recon process identify the remaining keys
             ReqIdx = lists:usort([Idx || {_Version, Idx} <- gb_trees:values(OtherDBChunk1)] ++ ToReqIdx1),
             ToReq2 = compress_idx_list(ReqIdx, OrigDBChunkLen, [], 0, 0),
             % the non-initiator will use key_upd_send and we must thus increase
             % the number of resolve processes here!
             NewStats2 =
                 if ReqIdx =/= [] ->
                        rr_recon_stats:inc([{resolve_started, 1}], NewStats);
                    true -> NewStats
                 end,
  
             ?TRACE("resolve_req Trivial Session=~p ; ToReq=~p (~p bits)",
                    [SID, length(ReqIdx), erlang:bit_size(ToReq2)]),
             comm:send(DestReconPid, {resolve_req, ToReq2}),
             
             shutdown(sync_finished,
  