anchor.diff:       (#xd5 4 2 zero-page-x)
        (#xd9 4 3 absolute-y)
        (#xdd 4 3 absolute-x))
  -  (let ((result (- (cpu-ar cpu) (funcall mode cpu))))
  +  (let ((result (- (cpu-ar cpu) (getter mode style cpu))))
       (set-flags-if cpu :carry (not (minusp result)))
       (set-flags-nz cpu result)))
   
  -(defopcode cpx (:docs "Compare Memory with X register")
  +(defasm cpx (:docs "Compare Memory with X register")
       ((#xe0 2 2 immediate)
        (#xe4 3 2 zero-page)
        (#xec 4 3 absolute))
  -  (let ((result (- (cpu-xr cpu) (funcall mode cpu))))
  +  (let ((result (- (cpu-xr cpu) (getter mode style cpu))))
       (set-flags-if cpu :carry (not (minusp result)))
       (set-flags-nz cpu result)))
   
  -(defopcode cpy (:docs "Compare Memory with Y register")
  +(defasm cpy (:docs "Compare Memory with Y register")
       ((#xc0 2 2 immediate)
        (#xc4 3 2 zero-page)
        (#xcc 4 3 absolute))
  -  (let ((result (- (cpu-yr cpu) (funcall mode cpu))))
  +  (let ((result (- (cpu-yr cpu) (getter mode style cpu))))
       (set-flags-if cpu :carry (not (minusp result)))
       (set-flags-nz cpu result)))
   
  -(defopcode dec (:docs "Decrement Memory")
  +(defasm dec (:docs "Decrement Memory")
       ((#xc6 5 2 zero-page)
        (#xce 6 3 absolute)
        (#xd6 6 2 zero-page-x)
        (#xde 7 3 absolute-x))
  -  (let ((result (wrap-byte (1- (funcall mode cpu)))))
  -    (funcall setf-form result)
  -    (set-flags-nz cpu result)))
  -
  -(defopcode dex (:docs "Decrement X register")
  +  (let ((result (wrap-byte (1- (getter mode style cpu)))))
  +    (setter mode result cpu)
  +    (set-flags-nz cpu result)))
  +
  +(defasm dex (:docs "Decrement X register")
       ((#xca 2 1 implied))
     (let ((result (setf (cpu-xr cpu) (wrap-byte (1- (cpu-xr cpu))))))
       (set-flags-nz cpu result)))
   
  -(defopcode dey (:docs "Decrement Y register")
  +(defasm dey (:docs "Decrement Y register")
       ((#x88 2 1 implied))
     (let ((result (setf (cpu-yr cpu) (wrap-byte (1- (cpu-yr cpu))))))
       (set-flags-nz cpu result)))
   
  -(defopcode eor (:docs "Exclusive OR with Accumulator")
  +(defasm eor (:docs "Exclusive OR with Accumulator")
       ((#x41 6 2 indirect-x)
        (#x45 3 2 zero-page)
        (#x49 2 2 immediate)
  
positive.code:      (#x95 4 2 zero-page-x)
       (#x99 5 3 absolute-y)
       (#x9d 5 3 absolute-x))
    (funcall setf-form (cpu-ar cpu)))
  
  (defopcode stx (:docs "Store X register" :addr-style :raw)
      ((#x86 3 2 zero-page)
       (#x8e 4 3 absolute)
       (#x96 4 2 zero-page-y))
    (funcall setf-form (cpu-xr cpu)))
  
  (defopcode sty (:docs "Store Y register" :addr-style :raw)
      ((#x84 3 2 zero-page)
       (#x8c 4 3 absolute)
       (#x94 4 2 zero-page-x))
    (funcall setf-form (cpu-yr cpu)))
  
  (defopcode tax (:docs "Transfer Accumulator to X register")
      ((#xaa 2 1 implied))
    (let ((result (setf (cpu-xr cpu) (cpu-ar cpu))))
      (set-flags-nz cpu result)))
  
  (defopcode tay (:docs "Transfer Accumulator to Y register")
      ((#xa8 2 1 implied))
    (let ((result (setf (cpu-yr cpu) (cpu-ar cpu))))
      (set-flags-nz cpu result)))
  
  (defopcode tsx (:docs "Transfer Stack Pointer to X register")
      ((#xba 2 1 implied))
    (let ((result (setf (cpu-xr cpu) (cpu-sp cpu))))
      (set-flags-nz cpu result)))
  
  (defopcode txa (:docs "Transfer X register to Accumulator")
      ((#x8a 2 1 implied))
    (let ((result (setf (cpu-ar cpu) (cpu-xr cpu))))
      (set-flags-nz cpu result)))
  
  (defopcode txs (:docs "Transfer X register to Stack Pointer")
      ((#x9a 2 1 implied))
    (setf (cpu-sp cpu) (cpu-xr cpu)))
  
  (defopcode tya (:docs "Transfer Y register to Accumulator")
      ((#x98 2 1 implied))
    (let ((result (setf (cpu-ar cpu) (cpu-yr cpu))))
      (set-flags-nz cpu result)))
  
negative.code:      (#x55 4 2 zero-page-x)
       (#x59 4 3 absolute-y)
       (#x5d 4 3 absolute-x))
    (let ((result (setf (cpu-ar cpu) (logxor (getter mode style cpu) (cpu-ar cpu)))))
      (set-flags-nz cpu result)))
  
  (defasm inc (:docs "Increment Memory")
      ((#xe6 5 2 zero-page)
       (#xee 6 3 absolute)
       (#xf6 6 2 zero-page-x)
       (#xfe 7 3 absolute-x))
    (let ((result (wrap-byte (1+ (getter mode style cpu)))))
      (setter mode result cpu)
      (set-flags-nz cpu result)))
  
  (defasm inx (:docs "Increment X register")
      ((#xe8 2 1 implied))
    (let ((result (setf (cpu-xr cpu) (wrap-byte (1+ (cpu-xr cpu))))))
      (set-flags-nz cpu result)))
  
  (defasm iny (:docs "Increment Y register")
      ((#xc8 2 1 implied))
    (let ((result (setf (cpu-yr cpu) (wrap-byte (1+ (cpu-yr cpu))))))
      (set-flags-nz cpu result)))
  
  (defasm jmp (:docs "Jump Unconditionally" :raw t :track-pc nil)
      ((#x4c 3 3 absolute)
       (#x6c 5 3 indirect))
    (setf (cpu-pc cpu) (getter mode style cpu)))
  
  (defasm jsr (:docs "Jump to Subroutine" :raw t :track-pc nil)
      ((#x20 6 3 absolute))
    (stack-push-word (wrap-word (1+ (cpu-pc cpu))) cpu)
    (setf (cpu-pc cpu) (getter mode style cpu)))
  
  (defasm lda (:docs "Load Accumulator from Memory")
      ((#xa1 6 2 indirect-x)
       (#xa5 3 2 zero-page)
       (#xa9 2 2 immediate)
  