anchor.diff:    (with-mod-r/m-byte
       (mov (indirect-address mod-bits r/m-bits t) (segment (bits->segment reg-bits)))))
   
  -(defun load-far-pointer (seg)
  +(defun load-far-pointer (seg mnemonic)
     (with-mod-r/m-byte
  -    (multiple-value-bind (address-base read-seg) (address-for-r/m mod-bits r/m-bits)
  -      (let* ((offset (case mod-bits (#b00 0) (#b01 (peek-at-instruction)) (#b10 (peek-at-word)) (#b11 0))) (real-base (+ address-base offset)) (read-seg-value (segment read-seg)))
  -	(setf (register (bits->word-reg reg-bits)) (segmented-word-in-ram read-seg-value real-base))
  -	(setf (segment seg) (segmented-word-in-ram read-seg-value (+ real-base 2)))))))
  +    (with-indirect-segment-offset mnemonic mod-bits r/m-bits
  +      (setf (register (bits->word-reg reg-bits)) indirect-offset)
  +      (setf (segment seg) indirect-segment))))
   
   ;; Flow control
  +
  +(defun jmp-far ()
  +  (disasm-instr (list "jmp" :op (list :offset (next-word) :segment (next-word)))
  +    (setf *ip* (next-word))
  +    (setf (segment :cs) (next-word))))
   
   (defun jmp-near ()
     (disasm-instr (list "jmp" :op (twos-complement (next-word) t))
  
positive.code:     ((= opcode #x3e) (segment-prefix :ds))
      ((= opcode #x8c) (mov-segment-to-indirect))
      ((= opcode #x8e) (mov-indirect-to-segment))
      ((= opcode #xc4) (load-far-pointer :es))
      ((= opcode #xc5) (load-far-pointer :ds))
      ((= opcode #xe9) (jmp-near))
      ((= opcode #xeb) (jmp-short))
      ((in-paired-byte-block-p opcode #x70) (jmp-short-conditionally opcode (flag-p :of) "o"))
  
negative.code:     ((in-paired-byte-block-p opcode #x7c) (jmp-short-conditionally opcode (not (eq (flag-p :of) (flag-p :sf))) "l"))
      ((in-paired-byte-block-p opcode #x7e) (jmp-short-conditionally opcode (or (flag-p :zf) (not (eq (flag-p :of) (flag-p :sf)))) "le"))
      ((= opcode #xe3) (jmp-short-on-cx-zero))
      ((= opcode #x9a) (call-far))
      ((= opcode #xe8) (call-near))
      ((= opcode #xc2) (ret-near-resetting-stack))
      ((= opcode #xc3) (ret-near))
      ((= opcode #xca) (ret-far-resetting-stack))
      ((= opcode #xcb) (ret-far))
      ((= opcode #xe0) (loop-instruction (not (flag-p :zf)) "ne"))
      ((= opcode #xe1) (loop-instruction (flag-p :zf) "e"))
      ((= opcode #xe2) (loop-instruction t ""))
  