anchor.diff:      ;; FIXME: Patch up initial thread's stack objects.
       (setf *global-thread-lock* :unlocked)
       (setf *thread-run-queue-head* nil)
  -    (setf *thread-run-queue-tail* nil)
  -    ;; The idle thread starts off with an empty stack. Fix it.
  -    (let ((rsp (thread-stack-pointer sys.int::*bsp-idle-thread*)))
  -      ;; Function to call.
  -      (setf (sys.int::memref-t (decf rsp 8) 0) #'idle-thread)
  -      ;; Trampoline for switch threads.
  -      (setf (sys.int::memref-signed-byte-64 (decf rsp 8) 0) (sys.int::%array-like-ref-signed-byte-64 #'%%idle-thread-trampoline 0))
  -      ;; Saved rbp.
  -      (setf (sys.int::memref-signed-byte-64 (decf rsp 8) 0) 0)
  -      (setf (thread-stack-pointer sys.int::*bsp-idle-thread*) rsp))))
  +    (setf *thread-run-queue-tail* nil))
  +  ;; The idle thread starts off with an empty stack. Fix it. (FIXME: Use the right stack pointer.)
  +  (let ((rsp (thread-stack-pointer sys.int::*bsp-idle-thread*)))
  +    ;; Function to call.
  +    (setf (sys.int::memref-t (decf rsp 8) 0) #'idle-thread)
  +    ;; Trampoline for switch threads.
  +    (setf (sys.int::memref-signed-byte-64 (decf rsp 8) 0) (sys.int::%array-like-ref-signed-byte-64 #'%%simple-thread-entry-trampoline 0))
  +    ;; Saved rbp.
  +    (setf (sys.int::memref-signed-byte-64 (decf rsp 8) 0) 0)
  +    (setf (thread-stack-pointer sys.int::*bsp-idle-thread*) rsp))
  +  ;; Reset the snapshot thread every boot. (FIXME: Use the right stack pointer.)
  +  (let ((rsp (thread-stack-pointer sys.int::*snapshot-thread*)))
  +    ;; Function to call.
  +    (setf (sys.int::memref-t (decf rsp 8) 0) #'snapshot-thread)
  +    ;; Trampoline for switch threads.
  +    (setf (sys.int::memref-signed-byte-64 (decf rsp 8) 0) (sys.int::%array-like-ref-signed-byte-64 #'%%simple-thread-entry-trampoline 0))
  +    ;; Saved rbp.
  +    (setf (sys.int::memref-signed-byte-64 (decf rsp 8) 0) 0)
  +    (setf (thread-stack-pointer sys.int::*snapshot-thread*) rsp)))
   
   (defun thread-yield ()
     (let ((current (current-thread)))
  
positive.code:      (sys.int::%cli)
       ;; Look for a thread to switch to.
       (let ((next (with-symbol-spinlock (*global-thread-lock*)
                     (pop-run-queue))))
         (cond (next
                ;; Switch to thread.
                (%lock-thread sys.int::*bsp-idle-thread*)
  
negative.code:   (setf (sys.int::%array-like-ref-t thread +thread-lock+) :unlocked))
  
  (defun push-run-queue (thread)
    (when (eql thread *world-stopper*)
      (return-from push-run-queue))
    (cond ((null *thread-run-queue-head*)
           (setf *thread-run-queue-head* thread
                 *thread-run-queue-tail* thread)
  