anchor.diff:                                                 gc_stats = Stats,
                                                  pending_nodes = Pending,
                                                  deleted_ages = DeletedAges,
  +                                               rr_reqs = RReqs,
                                                  tags = Tags} = S) ->
       print_gc_stats(Node, NodeStats),
       NewStats = add_gc_stats(Stats, NodeStats),
  
positive.code:     % The RR process has finished normally, and we can proceed to the
      % second phase of RR: start updating the tags.  Also, we
      % initialize the safe blacklist here.
      lager:info("GC: done with blob replication, entering rr_tags"),
      gen_server:cast(self(), {rr_tags, Tags}),
      {noreply, S#state{rr_pid = undefined,
                        safe_blacklist = gb_sets:from_list(BlackList),
                        phase = rr_tags}};
  
negative.code:                        last_response_time = now()}};
  
  handle_cast({rr_blob, '$end_of_table'},
              #state{phase = rr_blobs, rr_pid = RR, rr_reqs = RReqs} = S) ->
      % We are done with sending replication requests; we now wait for
      % the replicator to terminate.
      lager:info("GC: sent ~p blob replication requests, entering rr_blobs_wait",
                 [RReqs]),
      stop_replicator(RR),
      {noreply, S#state{phase = rr_blobs_wait}};
  handle_cast({rr_blob, Next}, #state{phase = rr_blobs, rr_reqs = RReqs} = S) ->
      Reqs = rereplicate_blob(S, Next),
      {noreply, S#state{rr_reqs = RReqs + Reqs}};
  handle_cast({add_replicas, BlobName, NewUrls}, #state{phase = Phase,
                                                        rr_reqs = RReqs} = S)
    when Phase =:= rr_blobs; Phase =:= rr_blobs_wait ->
      update_replicas(S, BlobName, NewUrls),
      lager:info("GC: ~p replication requests pending", [RReqs - 1]),
      {noreply, S#state{rr_reqs = RReqs - 1}};
  handle_cast({add_replicas, _BlobName, _NewUrls} = M, #state{phase = Phase,
                                                              rr_reqs = RReqs} = S) ->
      lager:info("GC: ignoring late response ~p (~p,~p)", [M, RReqs, Phase]),
      {noreply, S};
  
  handle_cast({rr_tags, [T|Tags], Count}, #state{phase = rr_tags} = S) ->
      S1 = update_tag(S, T, ?MAX_TAG_OP_RETRIES),
      lager:info("GC: updated tag ~p (~p)", [T, Count]),
      gen_server:cast(self(), {rr_tags, Tags, Count + 1}),
      {noreply, S1};
  handle_cast({rr_tags, [], Count}, #state{phase = rr_tags, gc_peers = Peers,
                                    safe_blacklist = Blacklist} = S) ->
      % We are done with the RR phase, and hence with GC!
      lager:info("GC: ~p tags updated/replication done, done with GC!", [Count]),
      node_broadcast(Peers, end_rr),
      % Update ddfs_master with the safe_blacklist.
      ddfs_master:safe_gc_blacklist(Blacklist),
  