anchor.diff:      R1 = Replies#rr_replies{reply_count=ReplyCount},
   
       %% update number of newest read rounds received
  -    MaxReadR = Replies#rr_replies.highest_r_round,
  +    MaxReadR = Replies#rr_replies.highest_read_round,
       R2 =
           if MaxReadR =:= SeenReadRound ->
  -                MaxRCount = R1#rr_replies.newest_r_reply_count + 1,
  -                R1#rr_replies{newest_r_reply_count=MaxRCount};
  +                MaxRCount = R1#rr_replies.highest_read_count + 1,
  +                R1#rr_replies{highest_read_count=MaxRCount};
              MaxReadR < SeenReadRound ->
  -                RT1 = R1#rr_replies{newest_r_reply_count=1},
  -                RT1#rr_replies{highest_r_round=SeenReadRound};
  +                RT1 = R1#rr_replies{highest_read_count=1},
  +                RT1#rr_replies{highest_read_round=SeenReadRound};
              true ->
                   R1
           end,
   
       %% update number of newest write rounds received
  -    MaxWriteR = Replies#rr_replies.highest_w_round,
  +    MaxWriteR = Replies#rr_replies.highest_write_round,
       R3 =
           if MaxWriteR =:= SeenWriteRound ->
  -                MaxWCount = R2#rr_replies.newest_w_reply_count + 1,
  -                T = R2#rr_replies{newest_w_reply_count=MaxWCount},
  +                MaxWCount = R2#rr_replies.highest_write_count + 1,
  +                T = R2#rr_replies{highest_write_count=MaxWCount},
                   NewVal = ?REDUNDANCY:collect_read_value(T#rr_replies.read_value,
                                                                 Value, Datatype),
                   T#rr_replies{read_value=NewVal};
              MaxWriteR < SeenWriteRound ->
  -                RT = R2#rr_replies{newest_w_reply_count=1},
  -                T = RT#rr_replies{highest_w_round=SeenWriteRound},
  +                RT = R2#rr_replies{highest_write_count=1},
  +                T = RT#rr_replies{highest_write_round=SeenWriteRound},
   
                   NewVal = ?REDUNDANCY:collect_newer_read_value(T#rr_replies.read_value,
                                                                 Value, Datatype),
  
positive.code:     {Result, R4} =
          case ?REDUNDANCY:quorum_accepted(ReplyCount) of
              true ->
                  case ReplyCount =:= R3#rr_replies.newest_r_reply_count andalso
                       ReplyCount =:= R3#rr_replies.newest_w_reply_count of
                      true ->
                          %% consistent quorum
                          Collected = R3#rr_replies.read_value,
  
negative.code: %% TODO: add support for *consistent* quorum by counting the number of
  %% same-round-number replies
  
  %% Aggregator for round_request replies.
  %% rr_replies are received after executing a read without round number
  %% to receive the currently highest rounds. If the replies are a
  %% consistent quorum, the read value can be directly delivered, otherwise
  %% a read with the highest round number is executed.
  -record(rr_replies, {reply_count :: non_neg_integer(),          %% total number of replies recieved
                       highest_read_count :: non_neg_integer(),   %% number of replies with current highest read round
                       highest_read_round :: pr:pr(),             %% highest read round received in replies
                       highest_write_count :: non_neg_integer(),  %% number of replies with current highest write round
                       highest_write_round :: pr:pr(),            %% highest write round recieved in replies
                       read_value :: any()                        %% value returned from the round_request
                      }).
  
  -type replies() :: gen_replies() | #rr_replies{}.
  