anchor.diff:                            andalso (length(SafePresent) >= S#state.blobk)) of
                           true ->
                               Update = {BlobName, filter},
  -                            collect_updates(S, Rest, [Update | Updates]);
  +                            collect(S, Rest, {[Update | Updates], NewSBL});
                           false ->
                               % Blacklist filtering is not needed, or
                               % it's not yet safe.
  -                            collect_updates(S, Rest, Updates)
  +                            collect(S, Rest, {Updates, NewSBL})
                       end;
                   [{_, _P, R, {update, NewUrls}}] ->
                       AccUpdates = add_blob_update(S, BlobName, R, NewUrls, Updates),
  -                    collect_updates(S, Rest, AccUpdates)
  +                    collect(S, Rest, {AccUpdates, NewSBL})
               end
       end.
   
  
positive.code:     {noreply, S};
  
  handle_cast({rr_tags, [T|Tags]}, #state{phase = rr_tags} = S) ->
      update_tag(S, T, ?MAX_TAG_OP_RETRIES),
      gen_server:cast(self(), {rr_tags, Tags}),
      {noreply, S};
  handle_cast({rr_tags, []}, #state{phase = rr_tags} = S) ->
      % We are done with the RR phase, and hence with GC!
      error_logger:info_report({"GC: tag update/replication done, done with GC!"}),
      node_broadcast(S#state.gc_peers, end_rr),
      % Exit with a non-normal error code to ensure all linked processes
      % die, especially gc_peers.
      {stop, done, S}.
  
negative.code:           pending_nodes     = gb_sets:empty() :: gb_set(),                % gc
            rr_next           = undefined       :: 'undefined' | rr_next(), % rr_blobs
            rr_pid            = undefined       :: 'undefined' | pid(),     % rr_blobs
            safe_blacklist    = gb_sets:empty() :: gb_set(),                % rr_tags
  
            % static state
            tags              = []      :: [object_name()],
  