anchor.diff:              (t nil)))))
   
   (defun disassemble-one-instruction (context)
  -  (let ((start (context-code-offset context))
  -        (inst (disassemble-one-instruction-1 context)))
  -    (cond (inst
  -           (values inst (- (context-code-offset context) start)))
  +  (let* ((start (context-code-offset context))
  +         (code-start 16)
  +         (code-end (+ code-start (sys.int::function-code-size (context-function context)))))
  +    (cond ((decoding-jump-table-p context)
  +           (let* ((dest (consume-ub64/le context))
  +                  (absolute-dest (+ (decoding-jump-table-p context) dest)))
  +             ;; Best guess...
  +             ;; If the destination is outside the function's code,
  +             ;; then this is probably past the end of the table.
  +             (cond ((<= code-start absolute-dest code-end)
  +                    (let ((inst (make-instruction :jump-target (decoding-jump-table-p context) dest)))
  +                      (setf (slot-value inst '%offset) start
  +                            (slot-value inst '%size) 8)
  +                      (label context absolute-dest :createp t)
  +                      inst))
  +                   (t
  +                    ;; Rewind & try again.
  +                    (setf (decoding-jump-table-p context) nil
  +                          (slot-value context '%offset) start)
  +                    (disassemble-one-instruction context)))))
             (t
  -           nil))))
  +           (let ((inst (disassemble-one-instruction-1 context)))
  +             (cond (inst
  +                    ;; Hack - Guess where jump tables start.
  +                    (when (and (eql (inst-opcode inst) 'sys.lap-x86:jmp)
  +                               (equal (inst-operands inst) '(:rax)))
  +                      (label context (context-code-offset context) :createp t)
  +                      (setf (decoding-jump-table-p context) (context-code-offset context)))
  +                    (setf (slot-value inst '%offset) start
  +                          (slot-value inst '%size) (- (context-code-offset context) start))
  +                    ;; Update labels.
  +                    (dolist (operand (inst-operands inst))
  +                      (when (and (typep operand 'effective-address)
  +                                 (eql (ea-base operand) :rip)
  +                                 (<= code-start
  +                                     (+ (context-code-offset context) (ea-disp operand))
  +                                     code-end))
  +                        (label context
  +                               (+ (context-code-offset context)
  +                                  (ea-disp operand))
  +                               :createp t)))
  +                    inst)
  +                   (t
  +                    (setf (slot-value context '%offset) (1+ start))
  +                    nil)))))))
  
positive.code: (defun disassemble (fn)
    (disassemble-function fn))
  
  (defun disassemble-function (fn &key gc-metadata debug-metadata)
    (when (and (consp fn) (eql (first fn) 'lambda))
      (setf fn (compile nil fn)))
    (when (not (functionp fn))
  
negative.code:       (disassemble-ordinary-modr/m context rex)
      (if (rex-w rex)
          (and opcode64
               (make-instruction opcode64
                                 (decode-gpr64 reg (rex-r rex))
                                 (decode-gpr64-or-mem r/m (rex-b rex))))
          (and opcode32
               (make-instruction opcode32
                                 (decode-gpr32 reg (rex-r rex))
                                 (decode-gpr32-or-mem r/m (rex-b rex)))))))
  
  (defun decode-ev64 (context opcode-byte rex group-table)
    (declare (ignore opcode-byte))
  