anchor.diff:  (define-u-b-alref sys.int::%array-like-ref-unsigned-byte-32 4 sys.lap-x86:mov32   sys.lap-x86:mov32 :eax)
   
   (defbuiltin sys.int::%array-like-ref-unsigned-byte-64 (array offset) ()
  -  (load-in-reg :r8 array t)
  -  (load-in-reg :r9 offset t)
  -  (fixnum-check :r9)
  -  (smash-r8)
  -  (emit `(sys.lap-x86:mov64 :rcx :r9)
  -        ;; Convert to raw integers.
  -        `(sys.lap-x86:sar64 :rax ,sys.int::+n-fixnum-bits+)
  -        `(sys.lap-x86:sar64 :rcx ,sys.int::+n-fixnum-bits+)
  -        ;; Read.
  -        `(sys.lap-x86:mov64 :rax ,(object-ea :r8 :index `(:rcx 8))))
  -  (box-unsigned-byte-64-rax)
  -  (setf *r8-value* (list (gensym))))
  +  (let ((constant-offset (and (constant-type-p offset `(signed-byte ,(- 64 sys.int::+n-fixnum-bits+)))
  +                              (second offset))))
  +    (unless constant-offset
  +      (load-in-reg :r10 offset t)
  +      (fixnum-check :r10)
  +      ;; Convert to unboxed integer.
  +      (emit `(sys.lap-x86:mov64 :rdi :r10)
  +            `(sys.lap-x86:sar64 :rdi ,sys.int::+n-fixnum-bits+)))
  +    (load-in-reg :r8 array t)
  +    ;; Read.
  +    (cond (constant-offset
  +           (emit `(sys.lap-x86:mov64 :rax ,(object-ea :r8 :slot constant-offset))))
  +          (t
  +           (emit `(sys.lap-x86:mov64 :rax ,(object-ea :r8 :index '(:rdi 8))))))
  +    (box-unsigned-byte-64-rax)
  +    (setf *r8-value* (list (gensym)))))
   
   (defbuiltin (setf sys.int::%array-like-ref-unsigned-byte-64) (new-value array offset) ()
     (let ((type-error-label (gensym))
           (bignum-path (gensym "alr-ub64-bignum"))
           (len-2-bignum (gensym "alr-ub64-len-2-bignum"))
  -        (value-extracted (gensym "alr-ub64-value-extracted")))
  +        (value-extracted (gensym "alr-ub64-value-extracted"))
  +        (constant-offset (and (constant-type-p offset `(signed-byte ,(- 64 sys.int::+n-fixnum-bits+)))
  +                              (second offset))))
       (emit-trailer (bignum-path)
         ;; Check for bignumness.
         (emit `(sys.lap-x86:and8 :dl #b1111)
  
positive.code: (defbuiltin (setf sys.int::%array-like-ref-signed-byte-64) (new-value array offset) ()
    (let ((type-error-label (gensym))
          (bignum-path (gensym "alr-sb64-bignum"))
          (value-extracted (gensym "alr-sb64-value-extracted")))
      (emit-trailer (bignum-path)
        ;; Check for bignumness.
        (emit `(sys.lap-x86:and8 :dl #b1111)
  
negative.code:           `(sys.lap-x86:jl ,type-error-label)
  	  ;; Convert to raw integer.
  	  `(sys.lap-x86:sar64 :rdx ,sys.int::+n-fixnum-bits+)
            value-extracted)
      (cond (constant-offset
             (emit `(sys.lap-x86:mov64 ,(object-ea :r9 :slot constant-offset) :rdx)))
            (t
             (emit `(sys.lap-x86:mov64 ,(object-ea :r9 :index '(:rdi 8)) :rdx))))
      *r8-value*))
  
  (defmacro define-s-b-alref (name width read-op write-op register)
    `(progn
       ;; Read function.
       (defbuiltin ,name (array offset) ()
         (let ((constant-offset (and (constant-type-p offset `(signed-byte ,(- 64 sys.int::+n-fixnum-bits+)))
                                     (second offset))))
           (unless constant-offset
             (load-in-reg :r10 offset t)
             (fixnum-check :r10)
             ;; Convert to unboxed integer.
             (emit `(sys.lap-x86:mov64 :rdi :r10)
                   `(sys.lap-x86:sar64 :rdi ,sys.int::+n-fixnum-bits+)))
           (load-in-reg :r9 array t)
           (smash-r8)
           ;; Read.
           (cond (constant-offset
                  (emit '(,read-op :rax (list :r9 (+ (- sys.int::+tag-object+) 8 (* constant-offset ,width))))))
                 (t
                  (emit '(,read-op :rax ,(object-ea :r9 :index `(:rdi ,width))))))
           ;; Convert to fixnum.
           (emit '(sys.lap-x86:lea64 :r8 ((:rax ,(ash 1 sys.int::+n-fixnum-bits+)))))
           (setf *r8-value* (list (gensym)))))
       ;; Write function.
       (defbuiltin (setf ,name) (new-value array offset) ()
         (let ((type-error-label (gensym))
               (constant-offset (and (constant-type-p offset `(signed-byte ,(- 64 sys.int::+n-fixnum-bits+)))
                                     (second offset))))
           (unless constant-offset
             (load-in-reg :r10 offset t)
             (fixnum-check :r10)
             ;; Convert to unboxed integer.
             (emit `(sys.lap-x86:mov64 :rcx :r10)
                   `(sys.lap-x86:sar64 :rcx ,sys.int::+n-fixnum-bits+)))
           (emit-trailer (type-error-label)
             (raise-type-error :r8 '(signed-byte ,(* width 8))))
           (load-in-reg :r9 array t)
           (load-in-r8 new-value t)
           (emit '(sys.lap-x86:mov64 :rax :r8)
                 '(sys.lap-x86:test64 :rax ,sys.int::+fixnum-tag-mask+)
  