anchor.diff:        (hash32-body char-ref))))
   
   (macrolet ((hash128-body (ref)
  -             `(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))
  -                      (c1 #x239b961b)
  -                      (c2 #xab0e9789)
  -                      (c3 #x38b34ae5)
  -                      (c4 #xa1e38b93))
  -                  (macrolet ((getblock (i)
  -                               `(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
  -                      (let ((k1 (getblock i))
  -                            (k2 (getblock (+ i 4)))
  -                            (k3 (getblock (+ i 8)))
  -                            (k4 (getblock (+ i 12))))
  -                        (declare (u32 k1 k2 k3 k4))
  -                        (*= k1 c1) (rotlf k1 15) (*= k1 c2) (^= h1 k1)
  -                        (rotlf h1 19) (+= h1 h2) (setf h1 (+ (* h1 5) #x561ccd1b))
  -                        (*= k2 c2) (rotlf k2 16) (*= k2 c3) (^= h2 k2)
  -                        (rotlf h2 17) (+= h2 h3) (setf h2 (+ (* h2 5) #x0bcaa747))
  -                        (*= k3 c3) (rotlf k3 17) (*= k3 c4) (^= h3 k3)
  -                        (rotlf h3 15) (+= h3 h4) (setf h3 (+ (* h3 5) #x96cd1c35))
  -                        (*= k4 c4) (rotlf k4 18) (*= k4 c1) (^= h4 k4)
  -                        (rotlf h4 13) (+= h4 h1) (setf h4 (+ (* h4 5) #x32ac3b17))))
  -                    (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)))))))
  +             (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)))
   
  
positive.code: 
  (deftype mod32 ()
    '(-> (u32 u32) u32))
  
  (declaim (inline + * << >> rotl ^))
  
  
negative.code: (declaim (ftype (-> (simple-string index) (unsigned-byte 8)) char-ref))
  
  (defun char-ref (string pos)
    (declare (optimize speed) (simple-base-string string) (index pos))
    (char-code (schar string pos)))
  
  (defmacro switch (value &body clauses)
  