anchor.diff:  (defun fast-find (char str str-len &optional (start 0))
     "Checks if CHAR is in STR. This function is supposed to be inlined."
     (declare (type character char)
  -           (type simple-string str)
  +           (type (simple-array character) str)
              (type array-index str-len start)
              (optimize (safety 0) (speed 3) (space 3)))
     (do ((i start (1+ i)))
  
positive.code:         (let* ((x-i (char x i))
                 (y-j (char y j))
                 (cost (if (char= x-i y-j) 0 1)))
            (declare (type character x-i y-j)
                     (type array-index cost))
            (setf (aref v1 (1+ j))
                  (min (1+ (aref v1 j))
                       (1+ (aref v0 (1+ j)))
                       (+  (aref v0 j) cost)))
            (when (and (plusp i) (plusp j))
              (let ((x-i-1 (char x (1- i)))
                    (y-j-1 (char y (1- j)))
                    (val (+ (aref v* (1- j)) cost)))
                (declare (type character x-i-1 y-j-1)
                         (type array-index val))
                (when (and (char= x-i y-j-1)
                           (char= x-i-1 y-j)
                           (< val (aref v1 (1+ j))))
  
negative.code: 
  (defun prefix-length (x y)
    "Calculates length of common prefix for strings X and Y."
    (declare (type (simple-array character) x y)
             (inline length)
             (optimize (safety 0) (speed 3) (space 3)))
    (let ((x-len (length x))
  