anchor.diff:      ((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 ""))
  
positive.code:   (with-mod-r/m-byte
      (mov (indirect-address mod-bits r/m-bits t) (segment (bits->segment reg-bits)))))
  
  (defun load-far-pointer (seg)
    (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)))))))
  
  ;; Flow control
  
  (defun jmp-near ()
    (disasm-instr (list "jmp" :op (twos-complement (next-word) t))
  
negative.code:     (if (zerop (register :cx))
  	(incf *ip* (twos-complement (next-instruction) nil)))))
  
  (defun call-far ()
    (disasm-instr (list "call" :op (list :offset (next-word) :segment (next-word)))
      (push-to-stack (segment :cs))
      (push-to-stack (+ *ip* 4))
      (setf *ip* (next-word))
      (setf (segment :cs) (next-word))))
  
  (defun call-near ()
    (disasm-instr (list "call" :op (twos-complement (next-word) t))
      (push-to-stack (+ *ip* 2))
      (incf *ip* (twos-complement (next-word) t))))
  
  (defun ret-far ()
    (disasm-instr '("retf")
      (setf *ip* (pop-from-stack))
      (setf (segment :cs) (pop-from-stack))))
  
  (defun ret-far-resetting-stack ()
    (disasm-instr (list "retf" :op (next-word))
      (ret-far)
      (incf (register :sp) (next-word))))
  
  (defun ret-near ()
    (disasm-instr '("retn")
  