anchor.diff:  
       lager:info("GC: entering gc phase"),
       OverusedPeer = find_peer(Peers, MostOverused),
  -    NewPeers = case OverusedPeer =/= undefined of
  -                   true ->
  +    NewPeers = case OverusedPeer of
  +                   undefined ->
  +                       Peers;
  +                   _ ->
                          node_send(OverusedPeer, {start_gc, overused}),
  -                       gb_trees:delete(MostOverused, Peers);
  -                   false ->
  -                       Peers
  +                       gb_trees:delete(MostOverused, Peers)
                  end,
       node_broadcast(NewPeers, {start_gc, normal}),
       % Update the last_response_time to indicate forward progress.
  
positive.code:             #state{phase = Phase, gc_peers = GCPeers,
                     num_pending_reqs = NumPendingReqs, most_overused_node = Overused} = S) ->
      lager:info("GC: retrying connection to ~p (in phase ~p)", [Node, Phase]),
      Mode = case Node =:= Overused of
                 true ->
                     overused;
                 false ->
                     normal
             end,
      Pid = ddfs_gc_node:start_gc_node(Node, self(), now(), Phase, Mode),
      Peers = update_peer(GCPeers, Node, Pid),
  
negative.code:                  find_unstable_nodes(NewNS),
                   FutureNS = estimate_rr_blobs(S#state{nodestats = NewNS}),
                   {NewUnderused , NewOverused} = find_unstable_nodes(FutureNS),
                   ok = case NewOverused of
                       [] -> ok;
                       _  -> rebalance(NewOverused, BL, FutureNS)
                   end,
  
                   lager:info("GC: entering rr_blobs phase"),
  