anchor.diff:  
   % Returns [CArc*], where length might be <= TakeN.
   
  -search_ring_by_point([], _SearchPoint, Ring, TakeN) ->
  -    util:take_ring_n(fun carc_not_member_by_addr/2,
  -                     Ring, TakeN, undefined);
  -
  -search_ring_by_point([#carc{pt_end = Point} | Rest] = CArcs,
  -                     SearchPoint, Ring, TakeN) ->
  +search_ring_by_point([], _SearchPoint, RingAsc, TakeN) ->
  +    util:take_ring_n(fun carc_not_member_by_addr/2, RingAsc, TakeN);
  +
  +search_ring_by_point([#carc{pt_end = Point} | Rest] = CArcsAsc,
  +                     SearchPoint, RingAsc, TakeN) ->
       % TODO: Do better than linear search.
  -    % For example, use erlang array instead of list.
  +    % For example, use erlang array instead of list for binary search.
       case SearchPoint =< Point of
           true  -> util:take_ring_n(fun carc_not_member_by_addr/2,
  -                                  CArcs, TakeN, Ring);
  -        false -> search_ring_by_point(Rest, SearchPoint, Ring, TakeN)
  +                                  CArcsAsc, TakeN, RingAsc);
  +        false -> search_ring_by_point(Rest, SearchPoint, RingAsc, TakeN)
       end.
   
   carc_not_member_by_addr(#carc{addr = Addr}, CArcs) ->
  
positive.code:     lists:map(fun (#carc{addr = Addr, data = Data}) -> {Addr, Data} end,
                CArcs).
  
  make(_Hash, [], CArcs) ->
      % TODO: Consider secondary sort on hash_ord to reduce (but not
      % eliminate) unlucky case when there's a hash collision.
      lists:keysort(#carc.pt_end, CArcs);
  
  make({HashMod, HashCfg} = Hash, [{Addr, Data} | Rest], Acc) ->
      Points = HashMod:hash_addr(Addr, HashCfg),
  
negative.code:     delta_check(
        [10, 20],
        [10, 15, 17, 20],
        [{n15, {10, 15}, n20},
         {n17, {15, 17}, n20}],
        [{n20, {17, 20}}]),
      delta_check(
        [10],
        [5, 10],
        [{n5, {10, max}, n10},
         {n5, {min, 5}, n10}],
        [{n10, {5, 10}}]),
      delta_check(
        [10, 20],
        [5, 10, 20],
        [{n5, {20, max}, n10},
         {n5, {min, 5}, n10}],
        [{n10, {5, 10}}]),
      delta_check(
        [10],
  