anchor.diff:      (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-string) seed (length s) mix-only))
  +           (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))
  
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:       (hash32-body char-ref))))
  
  (macrolet ((hash128-body (ref)
               (let ((c1 #x239b961b)
                     (c2 #xab0e9789)
                     (c3 #x38b34ae5)
                     (c4 #xa1e38b93))
                 `(multiple-value-bind (h1 h2 h3 h4)
                      (if (<= (integer-length seed) 32)
                          (values seed seed seed seed)
                          (values
                           (ldb (byte 32 0) seed)
                           (ldb (byte 32 32) seed)
                           (ldb (byte 32 64) seed)
                           (ldb (byte 32 96) seed)))
                    (declare (u32 h1 h2 h3 h4))
                    (let ((end (logand #xfffffff0 len)))
                      (macrolet ((getblock (i)
                                   `(mod32 (logior (,',ref vec ,i)
                                                   (ash (,',ref vec (+ ,i 1)) 8)
                                                   (ash (,',ref vec (+ ,i 2)) 16)
                                                   (ash (,',ref vec (+ ,i 3)) 24)))))
                        (loop for i from 0 below end by 16 do
                          (setf (values h1 h2 h3 h4)
                                (let* ((k1 (~> (getblock i)
                                               (* ,c1)
                                               (rotl 15)
                                               (* ,c2)))
                                       (h1 (~> h1
                                               (^ k1)
                                               (rotl 19)
                                               (+ h2)
                                               (* 5)
                                               (+ #x561ccd1b)))
                                       (k2 (~> (getblock (+ i 4))
                                               (* ,c2)
                                               (rotl 16)
                                               (* ,c3)))
                                       (h2 (~> h2
                                               (^ k2)
                                               (rotl 17)
                                               (+ h3)
                                               (* 5)
                                               (+ #x0bcaa747)))
                                       (k3 (~> (getblock (+ i 8))
                                               (* ,c3)
                                               (rotl 17)
                                               (* ,c4)))
                                       (h3 (~> h3
                                               (^ k3)
                                               (rotl 15)
                                               (+ h4)
                                               (* 5)
                                               (+ #x96cd1c35)))
                                       (k4 (~> (getblock (+ i 12))
                                               (* ,c4)
                                               (rotl 18)
                                               (* ,c1)))
                                       (h4 (~> h4
                                               (^ k4)
                                               (rotl 13)
                                               (+ h1)
                                               (* 5)
                                               (+ #x32ac3b17))))
                                  (declare (u32 k1 k2 k3 k4 h1 h2 h3 h4))
                                  (values h1 h2 h3 h4))))
                        (let ((k4 0) (k3 0) (k2 0) (k1 0))
                          (declare (u32 k4 k3 k2 k1)
                                   (dynamic-extent k4 k3 k2 k1))
                          (macrolet ((tail (n)
                                       `(,',ref vec (+ ,n end))))
                            (switch (logand len 15)
                              (15 (^= k4 (ash (tail 14) 16)))
                              (14 (^= k4 (ash (tail 13) 8)))
                              (13 (^= k4 (tail 12))
                                  (*= k4 ,c4) (rotlf k4 18) (*= k4 ,c1) (^= h4 k4))
  
                              (12 (^= k3 (ash (tail 11) 24)))
                              (11 (^= k3 (ash (tail 10) 16)))
                              (10 (^= k3 (ash (tail 9)   8)))
                              (9  (^= k3 (tail 8))
                                  (*= k3 ,c3) (rotlf k3 17) (*= k3 ,c4) (^= h3 k3))
  
                              (8 (^= k2 (ash (tail 7) 24)))
                              (7 (^= k2 (ash (tail 6) 16)))
                              (6 (^= k2 (ash (tail 5)  8)))
                              (5 (^= k2 (tail 4))
                                 (*= k2 ,c2) (rotlf k2 16) (*= k2 ,c3) (^= h2 k2))
  
                              (4 (^= k1 (ash (tail 3) 24)))
                              (3 (^= k1 (ash (tail 2) 16)))
                              (2 (^= k1 (ash (tail 1)  8)))
                              (1 (^= k1 (tail 0))
                                 (*= k1 ,c1) (rotlf k1 15) (*= k1 ,c2) (^= h1 k1)))))
  
                        (unless mix-only
  
                          (^= h1 len)
                          (^= h2 len)
                          (^= h3 len)
                          (^= h4 len)
  
                          (macrolet ((adds ()
                                       `(progn
                                          (+= h1 h2) (+= h1 h3) (+= h1 h4)
                                          (+= h2 h1) (+= h3 h1) (+= h4 h1))))
                            (adds)
  
                            (avalanche h1)
                            (avalanche h2)
                            (avalanche h3)
                            (avalanche h4)
  
                            (adds)))
  
                        (logior h1 (ash h2 32) (ash h3 64) (ash h4 96))))))))
  
    (locally (declare (optimize (speed 3) (safety 0) (debug 0)))
  
  