anchor.diff:        (sys.int::%cli)
         (lock-wait-queue mutex)
         ;; Try to acquire again, release may have been running.
  -      (when (sys.int::%cas-struct-slot mutex 4 nil self)
  +      (when (sys.int::%cas-struct-slot mutex 5 nil self)
           ;; We got it.
           (sys.int::%sti)
           (unlock-wait-queue mutex)
  -        (return-from acquire-mutex t))
  +        (return-from acquire-block-mutex t))
         ;; No good, have to sleep. Release will directly transfer ownership
         ;; to this thread.
         (push-wait-queue self mutex)
  
positive.code: 
  (defstruct (mutex
               (:include wait-queue)
               (:constructor make-mutex (&optional name))
               (:area :wired))
    ;; When NIL, the lock is free, otherwise is set to
    ;; the thread that holds the lock.
    (owner nil))
  
  (defun acquire-mutex (mutex wait-p)
    (let ((self (current-thread)))
      (assert (sys.int::%interrupt-state))
      (assert (not (thread-footholds-enabled-p self)))
      ;; Fast path - try to lock.
      (when (sys.int::%cas-struct-slot mutex 4 nil self)
        ;; We got it.
        (return-from acquire-mutex t))
      ;; Idiot check.
      (assert (not (mutex-held-p mutex)) (mutex)
              "Recursive locking detected.")
  
negative.code:       ;; todo: reenable footholds when the thread is sleeping, but only one level.
        ;; need to be careful with that, returning or unwinding from condition-wait
        ;; with the lock unlocked would be quite bad.
        (setf (thread-state self) :sleeping)
        (unlock-wait-queue condition-variable)
        (%reschedule)
  