anchor.diff:                  (emit `(,',write-op ,(list :r9 (+ (- sys.int::+tag-object+) 8 (* constant-offset ,width))) ,',register)))
                  (t
                   (emit '(,write-op ,(object-ea :r9 :index `(:rcx ,width)) ,register))))
  +         *r8-value*))
  +     (defbuiltin (setf ,(intern (format nil "~A-UNSCALED" name) (symbol-package name))) (new-value object 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 :rcx offset t)
  +           ;; Convert to unboxed integer.
  +           (emit `(sys.lap-x86:sar64 :rcx ,sys.int::+n-fixnum-bits+)))
  +         (load-in-reg :r9 object t)
  +         (load-in-r8 new-value t)
  +         (emit '(sys.lap-x86:mov64 :rax :r8)
  +               '(sys.lap-x86:sar64 :rax ,sys.int::+n-fixnum-bits+))
  +         ;; Write
  +         (cond (constant-offset
  +                (emit `(,',write-op ,(list :r9 (+ (- sys.int::+tag-object+) 8 constant-offset)) ,',register)))
  +               (t
  +                (emit '(,write-op ,(object-ea :r9 :index `(:rcx 1)) ,register))))
            *r8-value*))))
   
   (define-s-b-object-ref sys.int::%%object-ref-signed-byte-8  1 sys.lap-x86:movsx8  sys.lap-x86:mov8  :al)
  
positive.code:            (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-object-ref (name width read-op write-op register)
  
negative.code:            (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*))
  
  (defbuiltin sys.int::%object-ref-signed-byte-64-unscaled (object offset) ()
    (let ((overflow-label (gensym))
          (resume (gensym))
          (constant-offset (and (constant-type-p offset `(signed-byte ,(- 64 sys.int::+n-fixnum-bits+)))
                                (second offset))))
      (emit-trailer (overflow-label)
        ;; Undo the shift, then call the helper.
        (emit `(sys.lap-x86:rcr64 :rax 1))
        (emit `(sys.lap-x86:mov64 :r13 (:function sys.int::%%make-bignum-64-rax))
              `(sys.lap-x86:call ,(object-ea :r13 :slot sys.int::+fref-entry-point+))
              `(sys.lap-x86:jmp ,resume)))
      (unless constant-offset
        (load-in-reg :rdi offset t)
        ;; Convert to unboxed integer.
        (emit `(sys.lap-x86:sar64 :rdi ,sys.int::+n-fixnum-bits+)))
      (load-in-reg :r8 object t)
      (smash-r8)
      ;; Read.
      (cond (constant-offset
             (emit `(sys.lap-x86:mov64 :rax (:r8 ,(+ (- sys.int::+tag-object+) 8 constant-offset)))))
            (t
             (emit `(sys.lap-x86:mov64 :rax ,(object-ea :r8 :index '(:rdi 1))))))
      ;; Convert to fixnum & check for signed overflow.
      ;; Assumes fixnum size of 1!
      (emit `(sys.lap-x86:shl64 :rax 1)
            `(sys.lap-x86:jo ,overflow-label)
            `(sys.lap-x86:mov64 :r8 :rax)
            resume)
      (setf *r8-value* (list (gensym)))))
  
  (defbuiltin (setf sys.int::%object-ref-signed-byte-64-unscaled) (new-value object offset) ()
    (let ((type-error-label (gensym))
          (bignum-path (gensym "alr-sb64-bignum"))
          (value-extracted (gensym "alr-sb64-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)
              `(sys.lap-x86:cmp8 :dl ,sys.int::+tag-object+)
              `(sys.lap-x86:jne ,type-error-label)
              `(sys.lap-x86:mov64 :rdx ,(object-ea :r8 :slot -1))
              `(sys.lap-x86:and8 :dl ,(ash (1- (ash 1 sys.int::+object-type-size+))
                                           sys.int::+object-type-shift+))
              `(sys.lap-x86:cmp8 :dl ,(ash sys.int::+object-tag-bignum+
                                           sys.int::+object-type-shift+))
              `(sys.lap-x86:jne ,type-error-label)
              `(sys.lap-x86:and64 :rdx ,(lognot (1- (ash 1 sys.int::+object-data-shift+))))
              `(sys.lap-x86:cmp64 :rdx ,(ash 1 sys.int::+object-data-shift+))
              `(sys.lap-x86:jne ,type-error-label)
              `(sys.lap-x86:mov64 :rdx ,(object-ea :r8 :slot 0))
              `(sys.lap-x86:jmp ,value-extracted)
              type-error-label)
        (raise-type-error :r8 '(signed-byte 64)))
      (unless constant-offset
        (load-in-reg :rdi offset t)
        ;; Convert to unboxed integer.
        (emit `(sys.lap-x86:sar64 :rdi ,sys.int::+n-fixnum-bits+)))
      (load-in-reg :r9 object t)
      (load-in-r8 new-value t)
      (emit `(sys.lap-x86:mov64 :rdx :r8)
  	  `(sys.lap-x86:test64 :rdx ,sys.int::+fixnum-tag-mask+)
  	  `(sys.lap-x86:jnz ,bignum-path)
  	  ;; Convert to raw integer.
  	  `(sys.lap-x86:sar64 :rdx ,sys.int::+n-fixnum-bits+)
            value-extracted)
      ;; Write.
      (cond (constant-offset
             (emit `(sys.lap-x86:mov64 (:r9 ,(+ (- sys.int::+tag-object+) 8 constant-offset)) :rdx)))
            (t
             (emit `(sys.lap-x86:mov64 ,(object-ea :r9 :index '(:rdi 1)) :rdx))))
      *r8-value*))
  
  (defbuiltin sys.int::%object-ref-t (object offset) ()
  