anchor.diff:              shutdown(empty_interval, NewState)
       end;
   
  -on({create_struct, SenderI, {get_state_response, MyI}} = _Msg,
  +on({create_struct2, {get_state_response, MyI}} = _Msg,
      State = #rr_recon_state{stage = req_shared_interval, initiator = true,
                              method = RMethod,            dhtNodePid = DhtPid,
  -                           dest_rr_pid = DestRRPid,     struct = Params })
  +                           dest_rr_pid = DestRRPid,     struct = Params,
  +                           dest_interval = SenderI})
     when (RMethod =:= merkle_tree orelse RMethod =:= art) ->
       ?TRACE1(_Msg, State),
       % initiator got interval of client to create his own recon structure (merkle/art)
  
positive.code: 
  on({create_struct, RMethod, SenderI, Params, RcvInitiator} = _Msg, State) ->
      ?TRACE1(_Msg, State),
      This = comm:reply_as(comm:this(), 3, {create_struct, SenderI, '_'}),
      comm:send_local(State#rr_recon_state.dhtNodePid, {get_state, This, my_range}),
      State#rr_recon_state{method = RMethod, initiator = RcvInitiator, struct = Params};
  
  on({create_struct, SenderI, {get_state_response, MyI}} = _Msg,
     State = #rr_recon_state{stage = req_shared_interval, initiator = false,
                             method = RMethod,            dhtNodePid = DhtPid,
                             dest_rr_pid = DestRRPid}) ->
      ?TRACE1(_Msg, State),
      % target node got sync request, asked for its interval
      % struct contains the interval of the initiator
      % -> 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,
                                      sync_interval = SyncI},
      case intervals:is_empty(SyncI) of
          false ->
              send_chunk_req(DhtPid, self(), SyncI, SyncI, get_max_items(RMethod)),
  
negative.code:            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,
  