anchor.diff:      ?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)}),
  +    send_chunk_req(DhtNodePid, self(), MySyncI, MySyncI, get_max_items(RMethod), true),
       State#rr_recon_state{stage = reconciliation, struct = SyncStruct,
                            method = RMethod, initiator = true,
                            dest_recon_pid = DestReconPid};
  
positive.code:     NewState = State#rr_recon_state{stage = build_struct},
      case intervals:is_empty(SyncI) of
          false ->
              send_chunk_req(DhtPid, self(), SyncI, SenderSyncI, get_max_items(RMethod)),
              NewState;
          true ->
              shutdown(empty_interval, NewState)
  
negative.code:            SubSyncI = find_intersection(DestI, RestI),
             case intervals:is_empty(SubSyncI) of
                 false ->
                     MySubSyncI = find_intersection(RestI, DestI), % mapped to my range
                     Reconcile = Initiator andalso (Stage =:= reconciliation),
                     if RMethod =:= bloom -> 
                            ForkState = State#rr_recon_state{dest_interval = SubSyncI,
                                                             struct = Params},
                            {ok, Pid} = fork_recon(ForkState),
                            send_chunk_req(DhtNodePid, Pid, MySubSyncI, SubSyncI,
                                           get_max_items(RMethod), Reconcile);
                        true ->
                            send_chunk_req(DhtNodePid, self(), MySubSyncI, SubSyncI,
                                           get_max_items(RMethod), Reconcile)
                     end;
                 true -> ok
             end;
          true -> ok
      end,
      if EmptyRest orelse RMethod =:= bloom ->
             begin_sync(SyncStruct, Params, NewState#rr_recon_state{stage = reconciliation});
         true ->
             NewState % keep stage (at initiator: reconciliation, at other: build_struct)
      end.
  
  -spec begin_sync(MySyncStruct::sync_struct(), OtherSyncStruct::parameters(),
  