anchor.diff:                     (return itr)))))
           (setf (wfo-links wfo) '())
           (dolist (event (wfo-events wfo))
  -          (let ((link (deregister-from-event event wfo)))
  +          (let ((link (unregister-from-event event wfo)))
               (setf (cdr link) (wfo-links wfo)
                     (wfo-links wfo) link)))))))
   
  
positive.code:   ;; Loop required because the thread may be woken up and
    ;; not have any ready events.
    (loop
       (let ((completed (%call-on-wired-stack-without-interrupts
                         #'wfo-wait-1 nil
                         wfo)))
         (when completed
           (return completed)))
       ;; Unusual case: When WFO-WAIT-1 is interrupted via a foothold
       ;; the unsleep handler (set to WFO-DEREGISTER) will be run automatically.
       ;; A normal return from the foothold function will end up here while
       ;; an unwind wont. We must avoid running WFO-DEREGISTER twice.
       ;; The links slot will be non-NIL if WFO-DEREGISTER has already been run.
       (when (not (wfo-links wfo))
         (wfo-deregister wfo))))
  
  (defun wait-for-objects (&rest objects)
    ;; Objects converted to events.
  
negative.code:     ;; Sleep.
      (setf (thread-wait-item self) wfo
            (thread-state self) :sleeping
            (thread-unsleep-helper self) #'wfo-unsleep-helper
            (thread-unsleep-helper-argument self) wfo)
      (unlock-wait-queue wfo)
      (%reschedule-via-wired-stack sp fp)))
  
  (defun wfo-unsleep-helper (wfo)
    (declare (ignore wfo))
    nil)
  
  (defun wfo-unregister (wfo)
    (safe-without-interrupts (wfo)
      (with-place-spinlock (*big-wait-for-objects-lock*)
        ;; Unregister from events and reclaim the links.
        ;; This resets the WFO object and prepares it for re-waiting.
        (flet ((unregister-from-event (event marker)
                 (do ((itr (event-waiters event) (cdr itr))
                      (prev nil itr))
                     ((null itr)
  