anchor.diff:            ((and (not sp-involved)
                   (member extend '(nil :lsl :lsr :asr)))
              ;; Add (shifted register)
  +           (if is-64-bit
  +               (check-register-class lhs :gpr-64 :xzr)
  +               (check-register-class lhs :gpr-32 :wzr))
              (when (null extend)
                (setf extend :lsl
                      amount 0))
              (cond (is-64-bit
                     (assert (<= 0 amount 63))
  -                  (assert (member rhs-class '(:gpr-64 :xzr))))
  +                  (check-register-class rhs :gpr-64 :xzr))
                    (t
                     (assert (<= 0 amount 31))
  -                  (assert (member rhs-class '(:gpr-32 :wzr)))))
  +                  (check-register-class rhs :gpr-32 :wzr)))
              (emit-instruction (logior #x0b000000
                                        opc
                                        (ash (ecase extend
  
positive.code:                                        (ash (register-number reg) +rt-shift+)))
               (return-from instruction t))))))))
  
  (defun emit-ldstp-instruction (load-bit r1 r2 address)
    (multiple-value-bind (mode base offset)
        (parse-address address)
  
negative.code:             (ash (logand (- 64 shift) #x3f) 6)
              (1- width))))
  
  (defun emit-logical-instruction (opcode negate-bit dst lhs rhs shift amount)
    (let* ((dst-class (register-class dst))
           (is-64-bit (member dst-class '(:gpr-64 :sp :xzr)))
           (sf (if is-64-bit
                   #x80000000
                   #x00000000))
           (sp-involved (member dst-class '(:sp :wsp))))
      (check-register-class dst :gpr-64 :gpr-32 :sp :wsp :xzr :wzr)
      (if is-64-bit
          (check-register-class lhs :gpr-64 :xzr)
          (check-register-class :gpr-32 :wzr))
      (cond ((and (not negate-bit)
                  (null (register-class rhs))
                  (null shift)
                  (null amount)
                  (not (member dst-class '(:xzr :wzr))))
  