anchor.diff:              [N || {N, {Free, Used}} <- NodeStats,
               Used / (Free + Used) > AvgUsage + ?GC_BALANCE_THRESHOLD]
       end.
  +
  +-spec update_nodestats(node(), gc_run_stats(), [node_info()]) -> [node_info()].
  +update_nodestats(Node, {Tags, Blobs}, NodeStats) ->
  +    {_, {_, DelTag}} = Tags,
  +    {_, {_, DelBlob}} = Blobs,
  +    {_, {Free, Used}} = lists:keyfind(Node, 1, NodeStats),
  +    lists:keystore(Node, 1, NodeStats,
  +                   {Node, {Free + DelTag + DelBlob, Used - DelTag - DelBlob}}).
   
   -spec check_is_orphan(state(), object_type(), object_name(), node(), volume_name())
                        -> {ok, boolean() | unknown}.
  
positive.code:                  Sr = S#state{rr_pid = start_replicator(self())},
                   Start = ets:first(gc_blobs),
                   Reqs = rereplicate_blob(Sr, Start),
                   Sr#state{phase = rr_blobs, rr_reqs = RReqs + Reqs};
               Remaining ->
                   lager:info("GC: ~p nodes pending in gc", [Remaining]),
                   S
           end,
      {noreply, S1#state{pending_nodes = NewPending,
                         gc_stats = NewStats,
                         last_response_time = now()}};
  
  handle_cast({rr_blob, '$end_of_table'},
              #state{phase = rr_blobs, rr_pid = RR, rr_reqs = RReqs} = S) ->
  
negative.code:          end,
      {noreply, S1};
  
  handle_cast({gc_done, Node, GCNodeStats}, #state{phase = gc,
                                                 gc_stats = Stats,
                                                 pending_nodes = Pending,
                                                 deleted_ages = DeletedAges,
                                                 rr_reqs = RReqs,
                                                 nodestats = NodeStats,
                                                 tags = Tags} = S) ->
      print_gc_stats(Node, GCNodeStats),
      NewStats = add_gc_stats(Stats, GCNodeStats),
      NewPending = gb_sets:delete(Node, Pending),
      NewNodeStats = update_nodestats(Node, GCNodeStats, NodeStats),
      S1 = case gb_sets:size(NewPending) of
               0 ->
                   % This was the last node we were waiting for to
  