anchor.diff:  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   -spec on(message(), state()) -> state().
   on({get_state_response, MyI}, State = 
  -       #rr_recon_state{ recon_stage = build_struct,
  -                        recon_method = bloom,
  +       #rr_recon_state{ stage = build_struct,
  +                        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}] };
  +    State#rr_recon_state{ struct = [{interval, MyI}] };
   
   on({get_state_response, MyI}, State = 
  -       #rr_recon_state{ recon_stage = req_shared_interval,
  +       #rr_recon_state{ stage = req_shared_interval,
                           master = true,
  -                        recon_method = RMethod }) ->
  +                        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,
  +       #rr_recon_state{ stage = req_shared_interval,
                           master = false,
  -                        recon_method = Method,
  -                        recon_struct = Params,                        
  +                        method = Method,
  +                        struct = Params,                        
                           dhtNodePid = DhtPid,
                           dest_rr_pid = DestRUPid }) ->
       Method =:= merkle_tree andalso fd:subscribe(DestRUPid),
  
positive.code: start_to_dest(MyI, Req, #rr_recon_state{ dest_pid = DestPid,
                                           dhtNodePid = DhtPid,
                                           round = Round,
                                           ownerRemotePid = OwnerPid }) ->   
      case DestPid of
          random ->
              comm:send_local(DhtPid, 
                              {lookup_aux, select_sync_node(MyI), 0, 
                               {send_to_group_member, rrepair,
                                {continue_recon, OwnerPid, Round, Req}}});
          _ -> comm:send(DestPid, {send_to_group_member, rrepair,
                                   {continue_recon, OwnerPid, Round, Req}})
      end.
  
  % @doc selects a random associated key of an interval ending
  -spec select_sync_node(intervals:interval()) -> ?RT:key().
  select_sync_node(Interval) ->
      {_, _LKey, RKey, _RBr} = intervals:get_bounds(Interval),
      %Key = ?RT:get_split_key(_LKey, RKey, {1, randoms:rand_uniform(1, 10)}), %TODO    
      Key = case _RBr of
                ')' -> RKey - 1;
                ']' -> RKey
            end,
      Keys = lists:delete(Key, ?RT:get_replica_keys(Key)),
      util:randomelem(Keys).
  
  
negative.code:     State;
  
  on({get_chunk_response, {RestI, DBList}}, State =
         #rr_recon_state{ stage = build_struct,
                          method = RMethod,        
                          struct = Params,                    
                          round = Round,
                          dhtNodePid = DhtNodePid,
                          master = SyncMaster,
  