anchor.diff:                  merkle_tree -> req_shared_interval;        
                   art -> req_shared_interval
               end,
  -    State#rr_recon_state{ recon_stage = Stage, 
  -                          recon_struct = {},
  -                          recon_method = Method,
  +    State#rr_recon_state{ stage = Stage, 
  +                          struct = {},
  +                          method = Method,
                             dest_pid = DestPid,
                             master = true };
   
   on({continue, Method, Stage, Struct, Master}, State) ->
       comm:send_local(State#rr_recon_state.dhtNodePid, {get_state, comm:this(), my_range}),
  -    State#rr_recon_state{ recon_stage = Stage, 
  -                          recon_struct = Struct,
  -                          recon_method = Method,
  +    State#rr_recon_state{ stage = Stage, 
  +                          struct = Struct,
  +                          method = Method,
                             master = Master orelse Stage =:= res_shared_interval };
   
   on({crash, Pid}, State) ->
  
positive.code:             MyIntersec = mapInterval_to_range(Intersection, MyI, 2),
              send_chunk_req(DhtPid, self(), MyIntersec, Intersection, get_max_items(Method))
      end,
      State#rr_recon_state{ recon_stage = build_struct,
                            recon_struct = [{interval, Intersection}] };
  
  on({get_state_response, MyI}, State = 
         #rr_recon_state{ recon_stage = res_shared_interval,
                          recon_method = RMethod,
                          recon_struct = Params,
                          dhtNodePid = DhtPid,
                          dest_rr_pid = DestRRPid}) ->
      Interval = proplists:get_value(interval, Params),
  
negative.code:                           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) };    
      
  on({get_chunk_response, {RestI, DBList}}, State = 
         #rr_recon_state{ stage = reconciliation,
                          method = bloom,
                          dhtNodePid = DhtNodePid,
                          ownerLocalPid = Owner,
                          dest_rr_pid = DestRU_Pid,
                          struct = #bloom_recon_struct{ interval = BloomI, 
                                                              keyBF = KeyBF,
                                                              versBF = VersBF},
                          round = Round }) ->
  