anchor.diff:    ;; Interrupts must be off and the global thread lock must be held.
     ;; Releases the thread lock and reenables interrupts.
     (ensure-global-thread-lock-held)
  -  (let ((current (current-thread))
  -        (next (%update-run-queue)))
  -    (when (eql next current)
  -      ;; Staying on the same thread, unlock and return.
  -      (release-global-thread-lock)
  -      (%%return-to-same-thread sp fp)
  -      (panic "unreachable"))
  -    (when (<= (car sys.int::*exception-stack*)
  -              (thread-stack-pointer next)
  -              (1- (+ (car sys.int::*exception-stack*)
  -                     (cdr sys.int::*exception-stack*))))
  -      (panic "Other thread " next " stopped on exception stack!!!"))
  -    (ensure (eql (thread-state next) :runnable) "Switching to thread " next " with bad state " (thread-state next))
  -    (setf (thread-state next) :active)
  -    (%%switch-to-thread-via-wired-stack current sp fp next)))
  +  (let ((next (update-run-queue))
  +        (current (current-thread)))
  +    (cond ((eql next current)
  +           ;; Staying on the same thread, unlock and return.
  +           (release-global-thread-lock)
  +           (%%return-to-same-thread sp fp))
  +          (t
  +           (%%switch-to-thread-via-wired-stack current sp fp next)))
  +    (panic "unreachable")))
   
   (defun %reschedule-via-interrupt (interrupt-frame)
     ;; Switch to the next thread saving the full state.
     ;; Interrupts must be off and the global thread lock must be held.
     ;; Releases the thread lock and reenables interrupts.
     (ensure-global-thread-lock-held)
  -  (let ((current (current-thread))
  -        (next (%update-run-queue)))
  -    (when (not (eql next current))
  -      (ensure (eql (thread-state next) :runnable) "Switching to thread " next " with bad state " (thread-state next)))
  -    (setf (thread-state next) :active)
  +  (let ((next (update-run-queue))
  +        (current (current-thread)))
       (%%switch-to-thread-via-interrupt current interrupt-frame next)))
   
   (defun maybe-preempt-via-interrupt (interrupt-frame)
  
positive.code:                     ;; Fall back on idle.
                      (local-cpu-idle-thread))))))))
  
  ;;; Thread switching.
  
  (defun thread-yield ()
  
negative.code:   ;; Cancel the preemption timer, only used for scheduling normal threads.
    (preemption-timer-reset nil)
    (let ((current (current-thread)))
      ;; Return the current thread to the run queue and fetch the next thread.
      (when (and (not (eql current (local-cpu-idle-thread)))
                 (not (eql current *world-stopper*))
                 (eql (thread-state current) :runnable))
        (push-run-queue current))
      (cond (*world-stopper*
  