anchor.diff:                        (values (%line-breaks-1 string width offset margin start end) 0)))
                      ((>= start (aref opportunities next-opportunity-index))
                       (return-from breaks-rec
  -                      (breaks-rec offset margin start end (1+ next-opportunity-index)))))
  +                      (breaks-rec offset start end (1+ next-opportunity-index)))))
                (loop
                   with best-breaks = nil
                   with best-cost = nil
  
positive.code:   #-CMU
    `(declare (ignorable ,@variables)))
  
  ;; spread version:
  
  (defun declare-ignorable-form* (&rest variables)
    (declare-ignorable-form variables))
  
negative.code:                                                                    start opportunity))
                                        (new-start (alexandria:last-elt char-breaks)))
                                   (multiple-value-bind (breaks remaining-cost)
                                       (breaks-rec 0 new-start end i)
                                     (values (append char-breaks breaks) remaining-cost))))))
                          (t #1=(return-from breaks-rec
                                  (values best-breaks best-cost))))
                  finally #1#)))
      (breaks-rec initial-offset start end 0)))
  
  ;;; Implementing line breaking as defined in Unicode[1] is left as an
  ;;; excercise for the reader. When implemented it should be wired to
  ;;; the strategy designated by T. Current approach break on space, but
  ;;; in "real" languages lines may /need to/ or /must to/ be split under
  ;;; various conditions - hyphen, hard space, infix numeric separators
  ;;; etc. Optimally this should be implemented in cl-unicode and used
  ;;; from there.  [1] https://unicode.org/reports/tr14/ -- jd 2019-01-08
  (defun line-breaks (string width &key (break-strategy t) initial-offset margin (start 0) end)
    "Function takes a string and returns a list of indexes where it should be split.
  
  