anchor.diff:    (setf (process-whostate *current-process*) reason
           (process-wait-function *current-process*) function
           (process-wait-argument-list *current-process*) arguments)
  -  (process-yield))
  +  (process-yield)
  +  (setf (process-whostate *current-process*) nil))
   
   ;; todo, Fix this...
   (defun process-wait-with-timeout (reason timeout function &rest arguments)
  +  "Poll FUNCTION until it returns true, or until timeout expires.
  +Returns true if the timeout has not expired. TIMEOUT may be false, for infinite timeout."
     (declare (dynamic-extent arguments))
     (cond (timeout
            (process-wait reason (lambda ()
                                   (if (<= (decf timeout) 0)
                                       t
                                       (apply function arguments))))
  -         (<= timeout 0))
  +         (> timeout 0))
           (t (apply #'process-wait reason function arguments)
              t)))
   
  
positive.code:     (return-from grab-mutex t))
    (when wait-p
      (let ((process (current-process)))
        (process-wait-with-timeout (mutex-name mutex)
                                   timeout
                                   (lambda ()
                                     (when (not (mutex-owner mutex))
                                       (setf (mutex-owner mutex) process)
                                       t))))))
  
  (defun release-mutex (mutex &key (if-not-owner :error))
    (assert (not (%interrupt-state)))
  
negative.code: 
  (defun %maybe-preempt-from-interrupt-frame ()
    "Return a process to switch to, or NIL if the current process should keep running."
    ;; Must not preempt the GC.
    (when (and *preemption-enabled*
               (not *gc-in-progress*))
      (let ((next-process (or (get-next-process)
                              *idle-process*)))
        ;; Must not try to switch to current process.
        (when (not (eql next-process *current-process*))
          (setf *current-process* next-process)
          (process-stack-group next-process)))))
  
  (defun idle-process ()
    (loop
       (%cli)
       (let ((next-process (get-next-process)))
         (cond (next-process
                (setf *current-process* next-process)
  