anchor.diff:      (incf *ip* (twos-complement (next-instruction) nil))))
   
   (defmacro jmp-short-conditionally (opcode condition mnemonic)
  -  `(if (= (mod ,opcode #x02) 1)
  -       (disasm-instr (list (concatenate 'string "jn" ,mnemonic) :op1 (twos-complement (next-instruction) nil))
  +  `(let ((disp (next-instruction)))
  +     (if (evenp ,opcode)
  +       (disasm-instr (list (concatenate 'string "j" ,mnemonic) :op1 (twos-complement disp nil))
  +	 (when ,condition
  +	   (incf *ip* (twos-complement disp nil))))
  +       (disasm-instr (list (concatenate 'string "jn" ,mnemonic) :op1 (twos-complement disp nil))
   	 (unless ,condition
  -	   (incf *ip* (twos-complement (next-instruction) nil))))
  -       (disasm-instr (list (concatenate 'string "j" ,mnemonic) :op1 (twos-complement (next-instruction) nil))
  -	 (when ,condition
  -	   (incf *ip* (twos-complement (next-instruction) nil))))))
  +	   (incf *ip* (twos-complement disp nil)))))))
   
   (defun call-near ()
     (disasm-instr (list "call" :op1 (twos-complement (next-word) t))
  
positive.code:     (let ((address-base (address-for-r/m mod-bits r/m-bits)))
        (case mod-bits
  	(#b00 (if is-word (word-in-ram address-base *ram*) (byte-in-ram address-base *ram*)))
  	(#b01 (if is-word (word-in-ram (+ address-base (next-instruction)) *ram*) (byte-in-ram (+ address-base (next-instruction)) *ram*)))
  	(#b10 (if is-word (word-in-ram (+ address-base (next-word)) *ram*) (byte-in-ram (+ address-base (next-word)) *ram*)))
  	(#b11 (register (if is-word (bits->word-reg r/m-bits) (bits->byte-reg r/m-bits))))))))
  
  (defsetf indirect-address (mod-bits r/m-bits is-word) (value)
    "Write to an indirect address."
    `(let ((address-base (address-for-r/m ,mod-bits ,r/m-bits)))
      (case ,mod-bits
        (#b00 (if ,is-word (setf (word-in-ram address-base *ram*) ,value) (setf (byte-in-ram address-base *ram*) ,value)))
        (#b01 (if ,is-word (setf (word-in-ram (+ address-base (next-instruction)) *ram*) ,value) (setf (byte-in-ram (+ address-base (next-instruction)) *ram*) ,value)))
        (#b10 (if ,is-word (setf (word-in-ram (+ address-base (next-word)) *ram*) ,value) (setf (byte-in-ram (+ address-base (next-word)) *ram*) ,value)))
        (#b11 (setf (register (if ,is-word (bits->word-reg ,r/m-bits) (bits->byte-reg ,r/m-bits))) ,value)))))
  
  ;;; Instruction loader
  
  
negative.code: 
  (defmacro parse-alu-opcode (opcode operation)
    `(let ((mod-8 (mod ,opcode 8)))
       (case 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-bits r/m-bits)))
         (1
  	(with-mod-r/m-byte
  	  (,operation (register (bits->word-reg reg-bits)) (indirect-address mod-bits r/m-bits t) t mod-bits r/m-bits)))
         (2
  	(with-mod-r/m-byte
  	  (,operation (indirect-address mod-bits r/m-bits nil) (byte-register (bits->byte-reg reg-bits)) nil)))
         (3
  	(with-mod-r/m-byte
  	  (,operation (indirect-address mod-bits r/m-bits t) (register (bits->word-reg reg-bits)) t)))
         (4
  	(,operation (next-instruction) (byte-register :al) nil))
         (5
  	(,operation (next-word) (register :ax) t)))))
  
  (defmacro add-without-carry (src dest is-word &optional mod-bits r/m-bits)
    `(disasm-instr (list "add" :src ,src :dest ,dest)
       (with-in-place-mod ,dest ,mod-bits ,r/m-bits
         (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 &optional mod-bits r/m-bits)
    `(disasm-instr (list "adc" :src ,src :dest ,dest)
       (with-in-place-mod ,dest ,mod-bits ,r/m-bits
         (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 &optional mod-bits r/m-bits)
    `(disasm-instr (list "sub" :src ,src :dest ,dest)
       (with-in-place-mod ,dest ,mod-bits ,r/m-bits
         (let ((src-value ,src))
  	 (set-zf-on-op (set-sf-on-op (set-cf-on-sub (+ (decf ,dest src-value) src-value) src-value) ,is-word))))))
  
  (defmacro sub-with-borrow (src dest is-word &optional mod-bits r/m-bits)
    `(disasm-instr (list "sbb" :src ,src :dest ,dest)
       (with-in-place-mod ,dest ,mod-bits ,r/m-bits
         (let ((src-plus-cf (+ ,src (flag :cf))))
  	 (set-zf-on-op (set-sf-on-op (set-cf-on-sub (+ (decf ,dest src-plus-cf) src-plus-cf) src-plus-cf) ,is-word))))))
  
  (defmacro cmp-operation (src dest is-word &optional mod-bits r/m-bits)
    `(disasm-instr (list "cmp" :src ,src :dest ,dest)
       (set-zf-on-op (set-sf-on-op (set-cf-on-sub ,dest ,src) ,is-word))))
  
  (defmacro and-operation (src dest is-word &optional mod-bits r/m-bits)
    `(disasm-instr (list "and" :src ,src :dest ,dest)
       (with-in-place-mod ,dest ,mod-bits ,r/m-bits
         (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 &optional mod-bits r/m-bits)
    `(disasm-instr (list "or" :src ,src :dest ,dest)
       (with-in-place-mod ,dest ,mod-bits ,r/m-bits
         (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 &optional mod-bits r/m-bits)
    `(disasm-instr (list "xor" :src ,src :dest ,dest)
       (with-in-place-mod ,dest ,mod-bits ,r/m-bits
         (set-zf-on-op (set-sf-on-op (setf ,dest (logxor ,src ,dest)) ,is-word))
         (setf (flag-p :cf) nil))))
  
  (defmacro parse-group1-byte (opcode operation mod-bits r/m-bits)
    `(case (mod ,opcode 4)
      (0 (,operation (next-instruction-ahead-of-indirect-address ,mod-bits ,r/m-bits) (indirect-address ,mod-bits ,r/m-bits nil) nil mod-bits r/m-bits))
      (1 (,operation (next-word-ahead-of-indirect-address ,mod-bits ,r/m-bits) (indirect-address ,mod-bits ,r/m-bits t) t mod-bits r/m-bits))
      (3 (,operation (twos-complement (next-instruction-ahead-of-indirect-address ,mod-bits ,r/m-bits) nil) (indirect-address ,mod-bits ,r/m-bits t) t mod-bits r/m-bits))))
  
  (defmacro parse-group1-opcode (opcode)
    `(parse-group-opcode
  