anchor.diff:      ok.
   
   delta_check(Before, After, ExpectGrows) ->
  -    Grows = delta(Before, After),
  +    LessThenFunc = fun (X, Y) -> X < Y end,
  +    Grows = delta(Before, After, LessThenFunc),
   %   ?debugVal(Before),
   %   ?debugVal(After),
   %   ?debugVal(ExpectGrows),
  
positive.code:     ?assertEqual(ExpectGrows, Grows),
      ok.
  
  delta(Before, After) ->
      B1 = Before ++ [max],
      A1 = After ++ [max],
      G = delta(min, B1, min, A1, {Before, After}, []),
      case G of
          [{Node, {min, _NodePoint}, FromNode} | _] ->
              Last = case Before of
  
negative.code: 
  delta(BPrev, [B | BRest] = BList,
        APrev, [A | ARest] = AList,
        {Before, After, LessThenFunc} = BAFull, Grows) ->
      if B =:= max -> delta(BPrev, BList,
                            A, ARest,
                            BAFull,
                            [{A, {APrev, A}, delta_next(BList,
                                                        Before)} | Grows]);
         A =:= max -> delta(B, BRest,
                            APrev, AList,
                            BAFull,
                            [{delta_next(AList, After),
                              {BPrev, B},
                              delta_next(BList, Before)} | Grows]);
         true ->
              BLessThenA = LessThenFunc(B, A),
              case BLessThenA of
                  true  -> delta(B, BRest,
                                 APrev, AList,
                                 BAFull,
                                 [{A, {BPrev, B}, B} | Grows]);
                  false -> delta(BPrev, BList,
                                 A, ARest,
                                 BAFull,
                                 [{A, {APrev, A}, delta_next(BList,
                                                             Before)} | Grows])
              end
      end.
  
  delta_next(_, [])          -> undefined;
  