anchor.diff:  (defun forward-buffer-below (buffer &key elements not-followed-by restart-callback)
     "forwards the buffer until the index is at a position after which each of the values of <elements> are listed in sequence, followed by neither character of <not-followed-by>."
     (declare (type multi-buffer buffer)
  -           (type list elements)
  -           (type list not-followed-by)
  +           (type simple-string elements)
  +           (type simple-string not-followed-by)
              (type function restart-callback))
     (let ((bound (1+ (length elements))))
       (loop until (and (block elements-correct-p
                     (loop for n of-type fixnum from 1
  -                     for element of-type character in elements
  +                     for element of-type character across elements
                        unless (eql (n-peek-forward buffer n restart-callback)
                                    element)
                        do (return-from elements-correct-p nil))
                     T)
                   (not (find (n-peek-forward buffer bound restart-callback)
                            not-followed-by
  -                         :test (lambda (a b)
  -                                 (declare (type character a b))
  -                                 (eql a b)))))
  +                         :test #'eql)))
          do (buffer-forward buffer))))
   
   (defun forward-buffer-while-not (buffer char callback)
  
positive.code:         (leftover-index (- index)))
      (declare (type list lists-to-append)
               (type fixnum leftover-index))
      (loop named listwalker
         for string of-type simple-string in (multi-buffer-pstrings buffer)
         for stringlength = (length (the simple-string string))
         if (> stringlength leftover-index)
         do (progn (push leftover-index lists-to-append)
               (decf leftover-index stringlength))
         else
         do (return-from listwalker
              (apply #'concatenate 'string (nreverse (cons (subseq string (- stringlength leftover-index))
                                                           (nreverse lists-to-append))))))))
  
  (defun char-for-index (buffer index callback)
    "yields the character of <buffer> at <index>"
  
negative.code:                  (1+ (multi-buffer-index buffer))))
          ((and (< (multi-buffer-mark buffer) 0)
              (>= (multi-buffer-index buffer) 0))
           (the simple-string
             (concatenate 'string
                          (previous-buffer-content-from-index buffer (multi-buffer-mark buffer))
                          (subseq (multi-buffer-string buffer) 0 (1+ (multi-buffer-index buffer))))))
          (T ; both are negative
           (let ((upto-mark (previous-buffer-content-from-index buffer (multi-buffer-mark buffer))))
             (declare (type simple-string upto-mark))
  