anchor.diff:  
   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   
  +-spec build_struct(DBList::db_chunk_enc(), DestI::I, RestI::I, state()) -> state()
  +          when is_subtype(I, intervals:interval()).
  +build_struct(DBList, DestI, RestI,
  +             State = #rr_recon_state{method = RMethod, struct = Params,
  +                                     initiator = Initiator, stats = Stats,
  +                                     dhtNodePid = DhtNodePid}) ->
  +    {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
  +    if not EmptyRest ->
  +           SubSyncI = find_intersection(DestI, RestI),
  +           case intervals:is_empty(SubSyncI) of
  +               false ->
  +                   Pid = if RMethod =:= bloom -> 
  +                                erlang:element(2, fork_recon(State#rr_recon_state{dest_interval = SubSyncI,
  +                                                                                  struct = Params}));
  +                            true -> self()
  +                         end,
  +                   send_chunk_req(DhtNodePid, Pid, find_intersection(RestI, DestI), SubSyncI,
  +                                  get_max_items(RMethod));
  +               true -> ok
  +           end;
  +        true -> ok
  +    end,
  +    {NStage, NStats} =
  +        if EmptyRest orelse RMethod =:= bloom -> {reconciliation, begin_sync(SyncStruct, State)};
  +           not EmptyRest andalso RMethod =:= merkle_tree -> {build_struct, Stats};
  +           true -> {reconciliation, Stats}
  +        end,
  +    State#rr_recon_state{ stage = NStage,
  +                          struct = SyncStruct,
  +                          stats = rr_recon_stats:set([{build_time, BuildTime}], NStats) }.
  +
   -spec begin_sync(sync_struct(), state()) -> rr_recon_stats:stats().
  -begin_sync(SyncStruct, State = #rr_recon_state{ method = Method,
  -                                                struct = Params,
  -                                                ownerPid = OwnerL,
  -                                                dest_recon_pid = DestReconPid,
  -                                                dest_rr_pid = DestRRPid,
  -                                                initiator = Initiator,
  -                                                stats = Stats }) ->
  +begin_sync(MySyncStruct, State = #rr_recon_state{method = Method,
  +                                                 struct = Params,
  +                                                 ownerPid = OwnerL,
  +                                                 dest_recon_pid = DestReconPid,
  +                                                 dest_rr_pid = DestRRPid,
  +                                                 initiator = Initiator,
  +                                                 stats = Stats }) ->
       ?TRACE("BEGIN SYNC", []),
       SID = rr_recon_stats:get(session_id, Stats),
       case Method of
           merkle_tree -> 
               case Initiator of
                   true -> send(DestReconPid,
  -                             {check_nodes, comm:this(), [merkle_tree:get_hash(SyncStruct)]});
  +                             {check_nodes, comm:this(), [merkle_tree:get_hash(MySyncStruct)]});
                   false ->
  -                    SyncI = merkle_tree:get_interval(SyncStruct),
  +                    SyncI = merkle_tree:get_interval(MySyncStruct),
                       SyncParams = [{reconPid, comm:this()}],
                       send(DestRRPid,
                            {continue_recon, comm:make_global(OwnerL), SID,
  
positive.code:          bloom    = ?required(bloom_recon_struct, bloom)    :: ?REP_BLOOM:bloom_filter()         
          }).
  
  -type internal_params() :: {reconPid, comm:mypid()} |
                             {art, art:art()}.
  
  -type sync_struct() :: #bloom_recon_struct{} |
                         merkle_tree:merkle_tree() |
                         art:art().
  -type parameters() :: sync_struct() |
                        [internal_params()] |
                        [merkle_tree:mt_node()].
  -type recon_dest() :: ?RT:key() | random.
  
  
negative.code:     end;
  
  on({rr_recon, data, DestI, {get_chunk_response, {RestI, DBList0}}} = _Msg,
     State = #rr_recon_state{stage = build_struct}) ->
      ?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))],
      build_struct(DBList, DestI, RestI, State);
  
  on({start_recon, RMethod, SyncStruct, true = Initiator} = _Msg, State) ->
      ?TRACE1(_Msg, State),
      % initiator got other node's sync struct over sync interval (mapped to own range)
      % -> create own recon structure based on sync interval and reconcile
      % note: sync interval 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 retrieved the current range now!)
      case RMethod of
          bloom ->
              MySyncI = SyncStruct#bloom_recon_struct.interval,
              DestReconPid = undefined,
              ok;
  %%         merkle_tree -> % TODO
  %%             MySyncI = merkle_tree:get_interval(SyncStruct),
  %%             DestReconPid = proplists:get_value(reconPid, Params, undefined),
  %%             fd:subscribe(DestReconPid),
  %%             ok;
          art ->
              MySyncI = art:get_interval(SyncStruct),
              DestReconPid = undefined,
              ok
      end,
      % client only sends non-empty sync intervals or exits
      ?ASSERT(not intervals:is_empty(MySyncI)),
      
      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(RMethod)}),
      State#rr_recon_state{stage = reconciliation, struct = SyncStruct,
                           method = RMethod, initiator = Initiator,
                           dest_recon_pid = DestReconPid};
  
  on({reconcile, {get_chunk_response, {RestI, DBList0}}} = _Msg,
     State = #rr_recon_state{stage = reconciliation,     ownerPid = OwnerL,
  