anchor.diff:  
   ;;; Operations
   
  +;; Context wrappers
  +
   (defun with-one-byte-opcode-register (opcode fn)
     (let ((reg (bits->word-reg (mod opcode #x08))))
       (funcall fn reg)))
  +
  +(defmacro with-mod-r/m-byte (&body body)
  +  `(let* ((mod-r/m (next-instruction)) (r/m-bits (logand mod-r/m #b00000111)) (mod-bits (ash (logand mod-r/m #b11000000) -6)) (reg-bits (ash (logand mod-r/m #b00111000) -3)))
  +     ,@body))
  +
  +;; One-byte opcodes on registers
   
   (defun clear-carry-flag ()
     (disasm-instr '("clc")
  
positive.code: (defun bits->byte-reg (bits)
    (elt +bits-to-byte-register+ bits))
  
  ;;; Convenience functions
  
  (defun reverse-little-endian (low high)
  
negative.code: (defmacro parse-alu-opcode (opcode operation)
    `(let ((mod-8 (mod ,opcode 8)))
       (cond
         ((= mod-8 0)
  	(with-mod-r/m-byte
  	  (,operation (byte-register (bits->byte-reg reg-bits)) (indirect-address mod-bits r/m-bits nil) nil)))
         ((= mod-8 1)
  	(with-mod-r/m-byte
  	  (,operation (register (bits->word-reg reg-bits)) (indirect-address mod-bits r/m-bits t) t)))
         ((= mod-8 2)
  	(with-mod-r/m-byte
  	  (,operation (indirect-address mod-bits r/m-bits nil) (byte-register (bits->byte-reg reg-bits)) nil)))
         ((= mod-8 3)
  	(with-mod-r/m-byte
  	  (,operation (indirect-address mod-bits r/m-bits t) (register (bits->word-reg reg-bits)) t)))
         ((= mod-8 4)
  	(,operation (next-instruction) (byte-register :al) nil))
         ((= mod-8 5)
  	(,operation (next-word) (register :ax) t)))))
  
  (defmacro add-without-carry (src dest is-word)
    `(disasm-instr (list "add" :src ,src :dest ,dest)
       (set-zf-on-op (set-sf-on-op (set-cf-on-add (incf ,dest ,src)) ,is-word))))
  
  (defmacro add-with-carry (src dest is-word)
    `(disasm-instr (list "adc" :src ,src :dest ,dest)
       (set-zf-on-op (set-sf-on-op (set-cf-on-add (incf ,dest (+ ,src (flag :cf)))) ,is-word))))
  
  (defmacro sub-without-borrow (src dest is-word)
    `(disasm-instr (list "sub" :src ,src :dest ,dest)
       (set-zf-on-op (set-sf-on-op (set-cf-on-sub (decf ,dest ,src) ,src) ,is-word))))
  
  (defmacro sub-with-borrow (src dest is-word)
    `(disasm-instr (list "sbb" :src ,src :dest ,dest)
       (set-zf-on-op (set-sf-on-op (set-cf-on-sub (decf ,dest (+ ,src (flag :cf))) (+ ,src (flag :cf))) ,is-word))))
  
  (defmacro cmp-operation (src dest is-word)
    `(disasm-instr (list "cmp" :src ,src :dest ,dest)
       (set-zf-on-op (set-sf-on-op (set-cf-on-sub (- ,dest ,src) ,src) ,is-word))))
  
  (defmacro and-operation (src dest is-word)
    `(disasm-instr (list "and" :src ,src :dest ,dest)
       (set-zf-on-op (set-sf-on-op (setf ,dest (logand ,src ,dest)) ,is-word))
       (setf (flag-p :cf) nil)))
  
  (defmacro or-operation (src dest is-word)
    `(disasm-instr (list "or" :src ,src :dest ,dest)
       (set-zf-on-op (set-sf-on-op (setf ,dest (logior ,src ,dest)) ,is-word))
       (setf (flag-p :cf) nil)))
  
  (defmacro xor-operation (src dest is-word)
    `(disasm-instr (list "xor" :src ,src :dest ,dest)
       (set-zf-on-op (set-sf-on-op (setf ,dest (logxor ,src ,dest)) ,is-word))
       (setf (flag-p :cf) nil)))
  
  ;;; Opcode parsing
  