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:     end.
  
  delta_next(_, [])          -> undefined;
  delta_next([max], Restart) -> delta_next(Restart, []);
  delta_next([A | _], _)     -> A;
  delta_next([], Restart)    -> delta_next(Restart, []).
  
negative.code:     ok.
  
  delta_check(Before, After, _ExpectGrows, _ExpectShrinks) ->
      {Grows, Shrinks} = delta(Before, After),
  case false of
  true ->
      ?debugVal("------"),
      ?debugVal(Before),
      ?debugVal(After),
      % ?debugVal(ExpectGrows),
      ?debugVal(Grows),
      ?debugVal(Shrinks),
      % ?assertEqual(ExpectGrows, Grows),
      % ?assertEqual(ExpectShrinks, Shrinks),
  ok;
  false -> ok
  end,
      ok.
  
  delta(Before, After) ->
  