anchor.diff:  (defmacro parse-alu-opcode (opcode operation)
     `(let ((mod-8 (mod ,opcode 8)))
        (cond
  -       ; Add
  +       ((= 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 (byte-register :al) (next-instruction) nil))
  +	(,operation (next-instruction) (byte-register :al) nil))
          ((= mod-8 5)
  -	(,operation (register :ax) (next-word) t)))))
  +	(,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 ,src ,dest)) ,is-word))))
  +     (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 ,src (+ ,dest (flag :cf)))) ,is-word))))
  +     (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 ,src ,dest) ,dest) ,is-word))))
  +     (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 ,src (+ ,dest (flag :cf))) (+ ,dest (flag :cf))) ,is-word))))
  +     (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 (- ,src ,dest) ,dest) ,is-word))))
  +     (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 ,src (logand ,src ,dest)) ,is-word))
  +     (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 ,src (logior ,src ,dest)) ,is-word))
  +     (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 ,src (logxor ,src ,dest)) ,is-word))
  +     (set-zf-on-op (set-sf-on-op (setf ,dest (logxor ,src ,dest)) ,is-word))
        (setf (flag-p :cf) nil)))
   
   ;;; Opcode parsing
  
positive.code:      (setf (elt ,segment ,location) (logand ,value #x00ff))
       (setf (elt ,segment (1+ ,location)) (ash (logand ,value #xff00) -8))))
  
  ;;; Instruction loader
  
  (defun load-instructions-into-ram (instrs)
  
negative.code: 
  ;;; Test instructions
  
  (defparameter *test-instructions* #(#x40 #x40 #x05 #x03 #x00 #x91 #xb0 #xff #x04 #x01 #x72 #x04 #x50 #x5a #x51 #x52 #x48 #x4b #x43 #x74 #x03 #xbe #x02 #x03 #x01 #b11001111 #x47 #xf4) "Test instructions")
  