anchor.diff:    (:temporary (:sc unsigned-reg) t1 t2 t3 t4 count)
     (:generator 100
       (flet ((block-word (elem-offset)
  -             (make-ea :dword :base block
  -                      :index count
  -                      :scale 4
  -                      :disp (+ (- (* n-word-bytes vector-data-offset)
  -                                  other-pointer-lowtag)
  -                               (* 4 elem-offset)))))
  -      (let ((loop (gen-label))
  -            #+x86-64 (t1 (reg-in-size t1 :dword))
  -            #+x86-64 (t2 (reg-in-size t2 :dword))
  -            #+x86-64 (t3 (reg-in-size t3 :dword))
  -            #+x86-64 (t4 (reg-in-size t4 :dword)))
  +             (let ((disp (+ (- (* n-word-bytes vector-data-offset)
  +                               other-pointer-lowtag)
  +                            (* 4 elem-offset))))
  +               (dword-ea disp block count 4))))
  +      (let ((loop (gen-label)))
           ;; The code could definitely be improved for x86-64 by using
           ;; more temporaries, but this version works on both 32- and
           ;; 64-bit and eliminates many of the stupidities in the modular
  
positive.code:     (let* ((data-offset (- (* n-word-bytes vector-data-offset)
                               other-pointer-lowtag))
             (block-disp (+ data-offset bytes-to-copy))
             (ea-size #+x86 :dword #+x86-64 :qword)
             (immediate-offset (sc-is offset immediate))
             (unroll (if immediate-offset 2 1))
             (loop (gen-label)))
        (flet ((ea-for-buffer (&optional (offset 0))
                 (if immediate-offset
                     (make-ea ea-size :base buffer
                              :index block-index
                              :scale n-word-bytes
                              :disp (+ block-disp offset))
                     (make-ea ea-size :base buffer
                              :index buffer-index :disp data-offset)))
               (ea-for-block (&optional (offset 0))
                 (make-ea ea-size :base block
                          :index block-index
                          :scale n-word-bytes
                          :disp (+ block-disp offset)))
               (handle-endianness (x)
                 (when big-endian-p
                   (inst bswap x)
  
negative.code:         ;; the 32-bit version as well).
          (inst mov count 16)
          (emit-label loop)
          (dword-inst mov t1 (block-word -2))
          ;; sigma1
          (dword-inst mov t2 t1)
          (dword-inst rol t2 15)
          (dword-inst mov t3 t1)
          (dword-inst rol t3 13)
          (dword-inst xor t2 t3)
          (dword-inst shr t1 10)
          (dword-inst xor t1 t2)
          (dword-inst mov t2 (block-word -15))
          ;; sigma0
          (dword-inst mov t3 t2)
          (dword-inst rol t3 25)
          (dword-inst mov t4 t2)
          (dword-inst rol t4 14)
          (dword-inst xor t3 t4)
          (dword-inst shr t2 3)
          (dword-inst xor t2 t3)
          (dword-inst add t1 (block-word -7))
          (dword-inst add t2 (block-word -16))
          (dword-inst add t1 t2)
          (dword-inst mov (block-word 0) t1)
          (inst add count 1)
          (inst cmp count 63)
          (inst jmp :le loop)))))
  