anchor.diff:      %% tiebreaker.
       Offset = ReqId rem NVal,
   
  -    RingIndexInc = chash:ring_increment(RingSize),
  -    AllVnodes = list_all_vnode_ids(RingSize, RingIndexInc),
  +    AllVnodes = list_all_vnode_ids(RingSize),
       %% Older versions of this call chain used the same list of
       %% integers for both vnode IDs and partition IDs, which made for
       %% confusing reading. We can cheat a little less obnoxiously
  -    AllPartitions = lists:map(fun({vnode_id, Id, PC, Inc}) ->
  -                                      {partition_id, Id, PC, Inc} end,
  +    AllPartitions = lists:map(fun({vnode_id, Id, RS}) ->
  +                                      {partition_id, Id, RS} end,
                                 AllVnodes),
  -    UnavailableVnodes = identify_unavailable_vnodes(CHBin, RingIndexInc,
  -                                                    RingSize, Service),
  +    UnavailableVnodes = identify_unavailable_vnodes(CHBin, RingSize, Service),
   
       %% Create function to map coverage keyspaces to
       %% actual VNode indexes and determine which VNode
  
positive.code: %% instead of indexes as much as possible.
  
  %% ID, ring size, ring index increment
  -type vnode_id() :: {'vnode_id', non_neg_integer(), ring_size(), pos_integer()}.
  -type partition_id() :: {'partition_id', non_neg_integer(), ring_size(), pos_integer()}.
  
  %% Not a tagged tuple. ID + bits necessary to shift the ID to the left
  %% to create the subpartition index.
  
negative.code:                           ReqId, DownNodes, Service) ->
      {ok, CHBin} = riak_core_ring_manager:get_chash_bin(),
      RingSize = chashbin:num_partitions(CHBin),
  
      Offset = ReqId rem NVal,
      %% We have our own idea of what nodes are available. The client
  