anchor.diff:           dest_pid           = random                                    :: recon_dest(),             %dest dht node pid
            dest_rr_pid        = undefined                                 :: comm:mypid() | undefined, %dest rrepair pid
            dest_recon_pid     = undefined                                 :: comm:mypid() | undefined, %dest recon process pid
  -         recon_method       = undefined                                 :: method(),                 %reconciliation method
  -         recon_struct       = {}                                        :: recon_struct() | {},
  -         recon_stage        = reconciliation                            :: recon_stage(),
  +         method             = undefined                                 :: method(),                 %reconciliation method
  +         struct             = {}                                        :: struct() | {},
  +         stage              = reconciliation                            :: stage(),
            master             = false                                     :: boolean(),               %true if process is recon leader/initiator
            round              = 0                                         :: rrepair:round(),
            stats              = rr_recon_stats:new()                      :: rr_recon_stats:stats()
  
positive.code: %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  -spec on(message(), state()) -> state().
  on({get_state_response, MyI}, State = 
         #rr_recon_state{ recon_stage = build_struct,
                          recon_method = bloom,
                          dhtNodePid = DhtNodePid }) ->
      send_chunk_req(DhtNodePid, self(), MyI, mapInterval(MyI, 1), get_max_items(bloom)),
      State#rr_recon_state{ recon_struct = [{interval, MyI}] };
  
  on({get_state_response, MyI}, State = 
         #rr_recon_state{ recon_stage = req_shared_interval,
                          master = true,
                          recon_method = RMethod }) ->
      ReconReq = {continue, RMethod, req_shared_interval, [{interval, MyI}], false},
      start_to_dest(MyI, ReconReq, State),
      comm:send_local(self(), {shutdown, negotiate_interval_master}),
      State;
  
  on({get_state_response, MyI}, State = 
         #rr_recon_state{ recon_stage = req_shared_interval,
                          master = false,
                          recon_method = Method,
                          recon_struct = Params,                        
                          dhtNodePid = DhtPid,
                          dest_rr_pid = DestRUPid }) ->
      Method =:= merkle_tree andalso fd:subscribe(DestRUPid),
  
negative.code:             MyIntersec = mapInterval_to_range(Intersection, MyI, 2),
              send_chunk_req(DhtPid, self(), MyIntersec, Intersection, get_max_items(Method))
      end,
      State#rr_recon_state{ stage = build_struct,
                            struct = [{interval, Intersection}] };
  
  on({get_state_response, MyI}, State = 
         #rr_recon_state{ stage = res_shared_interval,
                          method = RMethod,
                          struct = Params,
                          dhtNodePid = DhtPid,
                          dest_rr_pid = DestRRPid}) ->
      Interval = proplists:get_value(interval, Params),
  