anchor.diff:                       :string-start start
                        :string-end end))
     point-y)
  -
  -(defun adjust-horizontal-scroll (window)
  -  (let ((screen (window-screen window))
  -        (buffer (window-buffer window)))
  -    (unless (variable-value 'line-wrap :default buffer)
  -      (let ((point-column (point-column (buffer-point buffer)))
  -            (width (- (screen-width screen) (screen-left-width screen))))
  -        (cond ((<= (+ (screen-horizontal-scroll-start screen) width)
  -                   (1+ point-column))
  -               (setf (screen-horizontal-scroll-start screen)
  -                     (- (1+ point-column) width)))
  -              ((< point-column (screen-horizontal-scroll-start screen))
  -               (setf (screen-horizontal-scroll-start screen) point-column)))))))
   
   (defun screen-display-lines (screen redraw-flag buffer view-charpos cursor-y)
     (let* ((*printing-tab-size* (variable-value 'tab-width :default buffer))
  
positive.code:     x))
  
  
  (defun redraw-line-p (y)
    (or (not *redraw-start-y*)
        (<= *redraw-start-y* y *redraw-end-y*)))
  
  (defun disp-print-line (screen y str/attributes do-clrtoeol
                          &key (start-x 0) (string-start 0) string-end)
    (unless (redraw-line-p y)
      (return-from disp-print-line nil))
    (destructuring-bind (str . attributes)
        str/attributes
      (when (null string-end)
        (setf string-end (length str)))
      (unless (and (= 0 string-start)
                   (= (length str) string-end))
        (setf str (subseq str
                          string-start
                          (if (null string-end)
                              nil
                              (min (length str) string-end))))
        (setf attributes (lem-base/line::subseq-elements attributes string-start string-end)))
      (let ((prev-end 0)
            (x start-x))
        (loop :for (start end attr) :in attributes
              :do (setf end (min (length str) end))
                  (setf x (screen-print-string screen x y (subseq str prev-end start) nil))
                  (setf x (screen-print-string screen x y (subseq str start end) attr))
                  (setf prev-end end))
        (setf x (screen-print-string screen x y
                                     (if (= prev-end 0)
                                         str
                                         (subseq str prev-end))
                                     nil))
        (when do-clrtoeol
          (lem-if:clear-eol *implementation* (screen-view screen) x y)))))
  
  #+(or)
  (progn
  
negative.code:       (loop :for (x string attribute) :in elements
              :do (lem-if:print-modeline *implementation* view x 0 string attribute)))))
  
  (defun adjust-horizontal-scroll (window)
    (let ((screen (window-screen window))
          (buffer (window-buffer window)))
      (unless (variable-value 'line-wrap :default buffer)
        (let ((point-column (point-column (buffer-point buffer)))
              (width (- (screen-width screen) (screen-left-width screen))))
          (cond ((<= (+ (screen-horizontal-scroll-start screen) width)
                     (1+ point-column))
                 (setf (screen-horizontal-scroll-start screen)
                       (- (1+ point-column) width)))
                ((< point-column (screen-horizontal-scroll-start screen))
                 (setf (screen-horizontal-scroll-start screen) point-column)))))))
  
  (defun redraw-display-window (window force)
    (let ((focus-window-p (eq window (current-window)))
          (buffer (window-buffer window))
  