anchor.diff:  
   default_wants_claim(Ring, Node) ->
       wants_claim_v1(Ring, Node).
  -
  -get_member_count(Ring, Node) ->
  -    %% Determine how many nodes are involved with the ring; if the requested
  -    %% node is not yet part of the ring, include it in the count.
  -    AllMembers = riak_core_ring:claiming_members(Ring),
  -    case lists:member(Node, AllMembers) of
  -        true ->
  -            length(AllMembers);
  -        false ->
  -            length(AllMembers) + 1
  -    end.
  -
  -get_expected_partitions(Ring, Node) ->
  -    riak_core_ring:num_partitions(Ring) div get_member_count(Ring, Node).
   
   wants_claim_v1(Ring) ->
       wants_claim_v1(Ring, node()).
  
positive.code:             claim_hole(Ring, Mine, CurrentOwners, Node)
      end.
  
  claim_hole(Ring, Mine, Owners, Node) ->
      Choices = case find_biggest_hole(Mine) of
                    {I0, I1} when I0 < I1 ->
                        %% start-middle of the ring
                        lists:takewhile(
                          fun({I, _}) -> I /= I1 end,
                          tl(lists:dropwhile(
                               fun({I, _}) -> I /= I0 end,
                               Owners)));
                    {I0, I1} when I0 > I1 ->
                        %% wrap-around end-start of the ring
                        tl(lists:dropwhile(
                             fun({I, _}) -> I /= I0 end, Owners))
                            ++lists:takewhile(
                                fun({I, _}) -> I /= I1 end, Owners);
                    {I0, I0} ->
                        %% node only has one claim
                        {Start, End} = 
                            lists:splitwith(
                              fun({I, _}) -> I /= I0 end,
                              Owners),
                        tl(End)++Start
                end,
      Half = length(Choices) div 2,
      {I, _} = lists:nth(Half, Choices),
      riak_core_ring:transfer_node(I, Node, Ring).
  
  find_biggest_hole(Mine) ->
      lists:foldl(fun({I0, I1}, none) ->
                          {I0, I1};
  
negative.code:                 none,
                  lists:zip(Mine, tl(Mine)++[hd(Mine)])).
  
  %% @private
  get_expected_partitions(Ring, Node) ->
      riak_core_ring:num_partitions(Ring) div get_member_count(Ring, Node).
  
  %% @private
  get_member_count(Ring, Node) ->
      %% Determine how many nodes are involved with the ring; if the requested
      %% node is not yet part of the ring, include it in the count.
      AllMembers = riak_core_ring:claiming_members(Ring),
      case lists:member(Node, AllMembers) of
          true ->
              length(AllMembers);
          false ->
              length(AllMembers) + 1
      end.
  
  %% ===================================================================
  %% Unit tests
  