anchor.diff:            ,break))))
   
   (macrolet ((hash32-body (ref)
  -             `(let* ((end (logand #xfffffffc len))
  -                     (c1 #xcc9e2d51)
  -                     (c2 #x1b873593)
  -                     (h1 seed))
  -                (declare (index end) (u32 h1))
  -                (loop for i of-type index below end by 4 do
  -                  (let ((k1 (logior (,ref vec i)
  -                                    (ash (,ref vec (+ i 1)) 8)
  -                                    (ash (,ref vec (+ i 2)) 16)
  -                                    (ash (,ref vec (+ i 3)) 24))))
  +             (let ((c1 #xcc9e2d51)
  +                   (c2 #x1b873593))
  +               `(let* ((end (logand #xfffffffc len))
  +                       (h1 seed))
  +                  (declare (index end) (u32 h1))
  +                  (loop for i of-type index below end by 4 do
  +                    (setf h1
  +                          (let* ((k1 (~> (mod32 (logior (,ref vec i)
  +                                                        (ash (,ref vec (+ i 1)) 8)
  +                                                        (ash (,ref vec (+ i 2)) 16)
  +                                                        (ash (,ref vec (+ i 3)) 24)))
  +                                         (* ,c1)
  +                                         (rotl 15)
  +                                         (* ,c2)))
  +                                 (h1 (~> h1
  +                                         (^ k1)
  +                                         (rotl 13)
  +                                         (* 5)
  +                                         (+ #xe6546b64))))
  +                            (declare (u32 k1 h1))
  +                            h1)))
  +                  (let ((k1 0))
                       (declare (u32 k1))
  -                    (*= k1 c1)
  -                    (rotlf k1 15)
  -                    (*= k1 c2)
  -                    (^= h1 k1)
  -                    (rotlf h1 13)
  -                    (setf h1 (+ (* h1 5) #xe6546b64))))
  -                (let ((k1 0))
  -                  (declare (u32 k1))
  -                  (switch (logand len 3)
  -                    (3 (^= k1 (ash (,ref vec (+ end 2)) 16)))
  -                    (2 (^= k1 (ash (,ref vec (+ end 1)) 8)))
  -                    (1 (^= k1 (,ref vec end))
  -                       (*= k1 c1)
  -                       (rotlf k1 15)
  -                       (*= k1 c2)
  -                       (^= h1 k1))))
  -                (unless mix-only
  -                  (^= h1 len)
  -                  (avalanche h1))
  -                h1)))
  +                    (switch (logand len 3)
  +                      (3 (^= k1 (ash (,ref vec (+ end 2)) 16)))
  +                      (2 (^= k1 (ash (,ref vec (+ end 1)) 8)))
  +                      (1 (^= k1 (,ref vec end))
  +                         (*= k1 ,c1)
  +                         (rotlf k1 15)
  +                         (*= k1 ,c2)
  +                         (^= h1 k1))))
  +                  (unless mix-only
  +                    (^= h1 len)
  +                    (avalanche h1))
  +                  h1))))
     (locally (declare (optimize (speed 3) (safety 0) (debug 0)))
   
       (defun hash32-octets (vec seed &optional (len (length vec)) mix-only)
  
positive.code: (declaim (ftype (-> (simple-string index) (unsigned-byte 8)) char-ref))
  
  (defun char-ref (string pos)
    (char-code (schar string pos)))
  
  (defmacro switch (value &body clauses)
  
negative.code:     (cond ((typep s 'simple-base-string)
             (funcall hash s seed (length s) mix-only))
            ((every (lambda (c) (typep c 'base-char)) s)
             (funcall hash (coerce s 'simple-base-string) seed (length s) mix-only))
            (t (let ((octets (babel:string-to-octets s)))
                 (ecase size
                   (32 (hash32-octets octets seed (length octets) mix-only))
  