anchor.diff:      (assert (not (logtest imm-value #b11)))
       (assert (<= -134217728 imm-value 134217727))
       (emit-instruction (logior #x14000000
  -                              (ldb (byte 19 2) imm-value)))
  +                              (ldb (byte 26 2) imm-value)))
       (return-from instruction t)))
   
   (define-instruction br (target)
  
positive.code:                                   #x80000000
                                    #x00000000)
                                #x1AC02000
                                (ash (register-number dst) +rd-shift+)
                                (ash (register-number lhs) +rn-shift+)
                                (ash (register-number rhs) +rm-shift+)))
      (return-from instruction t)))
  
negative.code: (define-addsub-instruction sub  1 nil)
  (define-addsub-instruction subs 1 t)
  
  (define-instruction adc (dst lhs rhs)
    (let* ((dst-class (register-class dst))
           (is-64-bit (member dst-class '(:gpr-64 :xzr)))
           (sf (if is-64-bit
                   #x80000000
                   #x00000000)))
      (cond (is-64-bit
             (check-register-class dst :gpr-64 :xzr)
             (check-register-class lhs :gpr-64 :xzr)
             (check-register-class rhs :gpr-64 :xzr))
            (t
             (check-register-class dst :gpr-32 :wzr)
             (check-register-class lhs :gpr-32 :wzr)
             (check-register-class rhs :gpr-32 :wzr)))
      (emit-instruction (logior sf
                                #x1A000000
                                       (ash (register-number rhs) +rm-shift+)
                                       (ash (register-number lhs) +rn-shift+)
                                       (ash (register-number dst) +rd-shift+)))
      (return-from instruction t)))
  
  (defun shifted-mask-p (value)
    (let ((v (logior value (1- value))))
      (zerop (logand (1+ v) v))))
  