anchor.diff:             send_chunk_req(pid_groups:get_my(dht_node), self(),
                             RestI, get_max_items()),
              State#rr_recon_state{kv_list = NewKVList,
  -                                misc = [{item_count, MyItemCount}]};
  +                                misc = [{item_count, MyDBSize1}]};
          true ->
              % here, the failure probability is correct (in contrast to the
              % non-initiator) since we know how many item checks we perform with the BF
  -           P1E_p1 = bloom_worst_case_failprob(BF, MyItemCount),
  +           P1E_p1 = bloom_worst_case_failprob(BF, MyDBSize1),
              Stats1  = rr_recon_stats:set([{p1e_phase1, P1E_p1}], Stats),
              % NOTE: use left-over P1E after phase 1 (bloom) for phase 2 (trivial RC)
              P1E_p2 = calc_n_subparts_p1e(1, P1E, (1 - P1E_p1)),
  
positive.code:             Params1 = Params,
              ?DBG_ASSERT(DestReconPid =/= undefined),
              fd:subscribe(self(), [DestRRPid]),
              P1E_p1 = 0.0, % needs to be set at the end of phase 1!
              Misc1 = Misc;
          art ->
              #art_recon_struct{art = ART, reconPid = DestReconPid} = Params,
              MySyncI = art:get_interval(ART),
              Params1 = Params,
              ?DBG_ASSERT(DestReconPid =/= undefined),
              P1E_p1 = 0.0, % TODO
              Misc1 = Misc
      end,
      % client only sends non-empty sync intervals or exits
  
negative.code: 
  on({process_db, {get_chunk_response, {RestI, DBList}}} = _Msg,
     State = #rr_recon_state{stage = reconciliation,    initiator = true,
                             method = shash,            stats = Stats,
                             params = #shash_recon_struct{sig_size = SigSize,
                                                          p1e = P1E} = Params,
                             kv_list = KVList,
                             misc = [{db_chunk, {OtherDBChunk, OrigDBChunkLen, MyDBSize}}]}) ->
      ?TRACE1(_Msg, State),
      % this is similar to the trivial sync above and the bloom sync below
  
      MyDBSize1 = MyDBSize + length(DBList),
      % identify differing items and the remaining (non-matched) DBChunk:
      {NewKVList, OtherDBChunk1} =
          shash_get_full_diff(DBList, OtherDBChunk, KVList, SigSize),
      NewState =
          State#rr_recon_state{kv_list = NewKVList,
                               misc = [{db_chunk, {OtherDBChunk1, OrigDBChunkLen, MyDBSize1}}]},
  
      %if rest interval is non empty start another sync
      SyncFinished = intervals:is_empty(RestI),
  