anchor.diff:                            `((lambda (s)
                                 (and (plusp (length s))
                                      (,',test ,(character suffix)
  -                                     (aref s (1- (length s))))))
  +                                            (aref s (1- (length s))))))
                               (string ,string))
                             call)))))
       (dcm string$= char=)
  
positive.code:                         `(defsubst ,name (,s1 ,s2 &key (start1 0) end1 (start2 0) end2 ,@keys)
                             ,@(unsplice docstring)
                             (declare (array-length start1 start2))
                             (let* ((,s1 (string ,s1))
                                    (,s2 (string ,s2))
                                    (end1 (or end1 (length ,s1)))
  
negative.code:              `(let (*print-pretty*)
                  (format nil ,control-string ,@args)))))
  
  (defun escape/no-arg-parsing (string table start end stream)
    (declare (string string)
             ((or function hash-table) table)
             ((or array-index null) start)
             ((or array-length null) end)
             (optimize (debug 0) (safety 1)
                       (compilation-speed 0)
                       (space 0))
             ;; Suppress unreachable code warnings.
             #+sbcl (sb-ext:muffle-conditions sb-ext:code-deletion-note))
    (let ((start (or start 0))
          (end (or end (length string))))
      (declare (array-index start)
               (array-length end))
      (with-string (stream stream)
        (with-type-dispatch (function hash-table) table
          (with-string-dispatch () string
            (flet ((rep (c)
                     (etypecase table
                       (function (funcall table c))
                       (hash-table (gethash c table)))))
              (declare (inline rep))
              (nlet escape ((start start))
                (when (< start end)
                  (let ((next (position-if #'rep string
                                           :start start
                                           :end end)))
                    (if (not next)
                        (write-string string stream :start start :end end)
                        (progn
                          (write-string string stream :start start :end next)
                          (let ((escape (rep (vref string next))))
                            (unless (emptyp escape)
                              (write-string escape stream))
                            (escape (1+ next))))))))))))))
  
  (defun escape (string table &key (start 0) end stream)
    "Write STRING to STREAM, escaping with TABLE.
  
  