anchor.diff:          end,
       State#rr_recon_state{ stage = NStage,
                             struct = SyncStruct,
  -                          stats = rr_recon_stats:set([{build_time, BuildTime}], NStats) };    
  -
  -on({rr_recon, data, DestI, {get_chunk_response, {RestI, DBList0}}}, State =
  -       #rr_recon_state{stage = reconciliation,         ownerPid = OwnerL,
  -                       method = bloom,                 dhtNodePid = DhtNodePid,
  -                       dest_rr_pid = DestRU_Pid,       stats = Stats,
  -                       struct = #bloom_recon_struct{ bloom = BF }}) ->
  -    % need to work in DestI (not SyncI, since that is a sub interval of our interval!)
  +                          stats = rr_recon_stats:set([{build_time, BuildTime}], NStats) };
  +
  +on({start_recon, bloom = Method, SyncStruct = #bloom_recon_struct{interval = MySyncI},
  +    true = Initiator} = _Msg, State) ->
  +    ?TRACE1(_Msg, State),
  +    % initiator got client's bloom recon structure over sync interval (mapped to own range)
  +    % -> reconcile own DB with received bloom filter
  +    % note: BloomI may be an outdated sub-interval of this node's range
  +    %       -> pay attention when saving values to DB!
  +    %       (it could be outdated then even if we retrieve the current range!)
  +    NewState = State#rr_recon_state{stage = reconciliation, struct = SyncStruct,
  +                                    method = Method, initiator = Initiator},
  +    case intervals:is_empty(MySyncI) of
  +        false ->
  +            DhtNodePid = State#rr_recon_state.dhtNodePid,
  +            Self = comm:reply_as(self(), 2, {reconcile, '_'}),
  +            send_local(DhtNodePid,
  +                       {get_chunk, Self, MySyncI, fun get_chunk_filter/1,
  +                        fun get_chunk_value/1, get_max_items(bloom)}),
  +            NewState;
  +        true ->
  +            shutdown(empty_interval, NewState)
  +    end;
  +
  +on({reconcile, {get_chunk_response, {RestI, DBList0}}} = _Msg,
  +   State = #rr_recon_state{stage = reconciliation,     ownerPid = OwnerL,
  +                           method = bloom,             dhtNodePid = DhtNodePid,
  +                           dest_rr_pid = DestRU_Pid,   stats = Stats,
  +                           struct = #bloom_recon_struct{bloom = BF},
  +                           initiator = true}) ->
  +    ?TRACE1(_Msg, State),
  +    % no need to map keys since the other node's bloom filter was created with
  +    % keys mapped to our interval
       Diff = [KeyX || {KeyX, VersionX} <- DBList0,
  -                    none =/= (Key = map_key_to_interval(KeyX, DestI)),
  -                    not ?REP_BLOOM:is_element(BF, encodeBlob(Key, VersionX))],
  +                    not ?REP_BLOOM:is_element(BF, encodeBlob(KeyX, VersionX))],
       %if rest interval is non empty start another sync    
       SID = rr_recon_stats:get(session_id, Stats),
       SyncFinished = intervals:is_empty(RestI),
  -    not SyncFinished andalso
  -        send_chunk_req(DhtNodePid, self(), RestI, RestI, get_max_items(bloom)),
  +    if not SyncFinished ->
  +            Self = comm:reply_as(self(), 2, {reconcile, '_'}),
  +            send_local(DhtNodePid,
  +                       {get_chunk, Self, RestI, fun get_chunk_filter/1,
  +                        fun get_chunk_value/1, get_max_items(bloom)});
  +       true -> ok
  +    end,
       ?TRACE("Reconcile Bloom Session=~p ; Diff=~p", [SID, length(Diff)]),
       NewStats =
           case Diff of
  
positive.code:     % -> client creates recon structure based on common interval, sends it to initiator
      RMethod =:= merkle_tree andalso fd:subscribe(DestRRPid),
      SyncI = find_intersection(MyI, SenderI),
      NewState = State#rr_recon_state{stage = build_struct},
      case intervals:is_empty(SyncI) of
          false ->
              send_chunk_req(DhtPid, self(), SyncI, SyncI, get_max_items(RMethod)),
              NewState;
          true ->
              shutdown(empty_interval, NewState)
  
negative.code:             shutdown(negotiate_interval, NewState)
      end;
  
  on({rr_recon, data, DestI, {get_chunk_response, {RestI, DBList0}}} = _Msg,
     State = #rr_recon_state{stage = build_struct,       initiator = Initiator,
                             method = RMethod,           dhtNodePid = DhtNodePid,
                             struct = Params,            stats = Stats}) ->
      ?TRACE1(_Msg, State),
      % create recon structure based on all elements in sync interval
      DBList = [encodeBlob(Key, VersionX) || {KeyX, VersionX} <- DBList0,
                                             none =/= (Key = map_key_to_interval(KeyX, DestI))],
      {BuildTime, SyncStruct} =
          case merkle_tree:is_merkle_tree(Params) of
              true ->
                  {BTime, NTree} = util:tc(merkle_tree, insert_list, [DBList, Params]),
                  {rr_recon_stats:get(build_time, Stats) + BTime, merkle_tree:gen_hash(NTree) };
              false ->
                  ToBuild = ?IIF(RMethod =:= art, ?IIF(Initiator, merkle_tree, art), RMethod),
                  util:tc(fun() -> build_recon_struct(ToBuild, {DestI, DBList}) end)
          end,
      EmptyRest = intervals:is_empty(RestI),
      % bloom may fork more recon processes if un-synced elements remain
  