anchor.diff:  
   (define-instruction str (reg value)
     (let* ((class (register-class reg))
  -         (size-bit (ecase class
  -                     (:gpr-64 +ldst-size-64-bit+)
  -                     (:gpr-32 +ldst-size-32-bit+))))
  +         (is-64-bit (member class '(:gpr-64 :xzr)))
  +         (size-bit (if is-64-bit
  +                       +ldst-size-64-bit+
  +                       +ldst-size-32-bit+)))
  +    (check-register-class reg :gpr-64 :gpr-32 :xzr :wzr)
       (multiple-value-bind (mode base offset)
           (parse-address value)
         (ecase mode
           (:base-plus-immediate
            (let ((imm-value (or (resolve-immediate offset) 0)))
  -           (cond ((and (eql class :gpr-32)
  +           (cond ((and (not is-64-bit)
                          (<= 0 imm-value 16380)
                          (zerop (logand imm-value #b11)))
                     ;; STR (immediate, unsigned offset).
  
positive.code:     (:wzr :wzr)
      (:xzr :xzr)
      (:pc :pc)))
  
  (defun register-number (register &optional restrict-to)
    (when restrict-to
  
negative.code:          (rhs-class (register-class rhs))
           (sp-involved (or (member dst-class '(:sp :wsp))
                            (member lhs-class '(:sp :wsp)))))
      (if s-bit
          (check-register-class dst :gpr-64 :gpr-32 :xzr :wzr)
          (check-register-class dst :gpr-64 :gpr-32 :sp :wsp))
      (cond ((null rhs-class)
             ;; Add (immediate)
             (if is-64-bit
                 (check-register-class lhs :gpr-64 :sp)
                 (check-register-class lhs :gpr-32 :wsp))
             (when (null extend)
               (setf extend :lsl))
             (when (null amount)
  