anchor.diff:  start_to_dest(MyI, Req, #rr_recon_state{ dest_pid = DestPid,
                                            dhtNodePid = DhtPid,
                                            round = Round,
  -                                         ownerRemotePid = OwnerPid }) ->   
  +                                         ownerRemotePid = OwnerPid }) ->
  +    Msg = {send_to_group_member, rrepair, {continue_recon, OwnerPid, Round, Req}},
       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}})
  +        random -> comm:send_local(DhtPid, {lookup_aux, select_sync_node(MyI), 0, Msg});
  +        _ -> comm:send(DestPid, Msg)
       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,
  +    {_, LKey, RKey, _} = intervals:get_bounds(Interval),
  +    Key = ?RT:get_split_key(LKey, RKey, {1, randoms:rand_uniform(1, 50)}),
       Keys = lists:delete(Key, ?RT:get_replica_keys(Key)),
       util:randomelem(Keys).
   
  
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: %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  on({check_node, SenderPid, Interval, Hash}, State =
         #rr_recon_state{ struct = Tree }) ->
      Node = merkle_tree:lookup(Interval, Tree),
      {Result, ChildHashs} = 
          case Node of
  