anchor.diff:                    % empty BF with diff at our node -> the other node does not have any items!
                     % start a resolve here:
                     NewStats = send_resolve_request(
  -                               Stats, [element(1, KV) || KV <- NewKVList], OwnerL,
  +                               Stats1, [element(1, KV) || KV <- NewKVList], OwnerL,
                                  DestRRPid, true, false),
                     NewState = State#rr_recon_state{stats = NewStats, stage = resolve,
                                                     kv_list = NewKVList},
  -                  shutdown(sync_finished, NewState);
  +                  shutdown(sync_finished, NewState#rr_recon_state{stats = Stats1});
                 BFCount =:= 0 ->
  -                  shutdown(sync_finished, State#rr_recon_state{kv_list = NewKVList});
  +                  shutdown(sync_finished, State#rr_recon_state{stats = Stats1, kv_list = NewKVList});
                 true -> % BFCount > 0
                     % must send resolve_req message for the non-initiator to shut down
                     send(DestReconPid, {resolve_req, shutdown}),
                     % note: kv_list has not changed, we can thus use the old State here:
  -                  shutdown(sync_finished, State)
  +                  shutdown(sync_finished, State#rr_recon_state{stats = Stats1})
              end
       end;
   
  
positive.code:                   % the non-initiator will use key_upd_send and we must thus increase
                    % the number of resolve processes here!
                    NewStats1 = rr_recon_stats:inc([{rs_expected, 1},
                                                    {build_time, BuildTime}], Stats),
                    NewStats  = rr_recon_stats:set([{p1e_phase2, P1E_p2_real}], NewStats1),
                    State#rr_recon_state{stats = NewStats, stage = resolve,
                                         kv_list = [],
  
negative.code:     P1E_sub = calc_n_subparts_p1e(2, P1E),
      1 - math:pow(1 - P1E_sub, 1 / erlang:max(MaxItems, 1)).
  
  %% @doc Calculates the worst-case failure probability of the bloom algorithm
  %%      with the Bloom filter and number of items to check inside the filter.
  %%      NOTE: Precision loss may occur for very high values!
  -spec bloom_worst_case_failprob(
          BF::bloom:bloom_filter(), ItemCount::non_neg_integer()) -> float().
  bloom_worst_case_failprob(_BF, 0) ->
      0.0;
  bloom_worst_case_failprob(BF, ItemCount) ->
      Fpr = bloom:get_property(BF, fpr),
      1 - math:pow(1 - Fpr, ItemCount).
  
  -spec build_recon_struct(method(), DestI::intervals:non_empty_interval(),
                           db_chunk_kv(), Params::parameters() | {})
          -> {sync_struct(), P1E_p1::float()}.
  