anchor.diff:      (load-in-r8 new-value t)
       (emit `(sys.lap-x86:mov64 :rdx :r8)
   	  `(sys.lap-x86:test64 :rdx #b111)
  -	  `(sys.lap-x86:jnz ,type-error-label)
  +	  `(sys.lap-x86:jnz ,bignum-path)
   	  ;; Convert to raw integers, leaving offset correctly scaled (* 8).
  +	  `(sys.lap-x86:sar64 :rdx 3)
  +          value-extracted
   	  `(sys.lap-x86:sar64 :rax 3)
  -	  `(sys.lap-x86:sar64 :rdx 3)
   	  ;; Write.
   	  `(sys.lap-x86:mov64 (:rax :rcx) :rdx))
       *r8-value*))
  
positive.code:           `(sys.lap-x86:mov64 :rax (:rax :rcx))
            ;; Check for overflow. Top 3 bits must be all 0 or all 1.
            `(sys.lap-x86:mov64 :rdx :rax)
            `(sys.lap-x86:sar64 :rdx 61)
            `(sys.lap-x86:jz ,ok-label)
            `(sys.lap-x86:cmp8 :dl -1)
            `(sys.lap-x86:jne ,overflow-error-label)
  
negative.code:     (setf *r8-value* (list (gensym)))))
  
  (defbuiltin (setf sys.int::memref-signed-byte-64) (new-value base offset) ()
    (let ((type-error-label (gensym))
          (bignum-path (gensym "mr-sb64-bignum"))
          (value-extracted (gensym "mr-sb64-value-extracted")))
      (emit-trailer (bignum-path)
        ;; Check for bignumness.
        (emit `(sys.lap-x86:and8 :dl #b1111)
              `(sys.lap-x86:cmp8 :dl #.sys.int::+tag-array-like+)
              `(sys.lap-x86:jne ,type-error-label)
              `(sys.lap-x86:mov64 :rdx (:simple-array-header :r8))
              `(sys.lap-x86:cmp8 :dl #.(ash sys.int::+array-type-bignum+ 3))
              `(sys.lap-x86:jne ,type-error-label)
              `(sys.lap-x86:shr64 :rdx 8)
              ;; RDX = bignum length.
              `(sys.lap-x86:cmp64 :rdx 1)
              `(sys.lap-x86:jne ,type-error-label)
              `(sys.lap-x86:mov64 :rdx (:r8 #.(+ (- sys.int::+tag-array-like+) 8)))
              `(sys.lap-x86:jmp ,value-extracted)
              type-error-label)
        (raise-type-error :r8 '(signed-byte 64)))
      (load-in-reg :rax base t)
      (fixnum-check :rax)
  