anchor.diff:  
   (defun make-watcher-event-monitor (watcher object event)
     "Create a new event watcher monitor."
  -  ;; Structured so that CONS-IN-AREA isn't called inside the pool lock.
  -  (flet ((pop-pool ()
  -           (let ((monitor (object-pool-pop *watcher-monitor-pool*)))
  -             (when monitor
  -               (setf (watcher-event-monitor-watcher monitor) watcher
  -                     (watcher-event-monitor-event monitor) event
  -                     (watcher-event-monitor-object monitor) object)
  -               monitor))))
  -    (declare (dynamic-extent #'pop-pool))
  -    (or (pop-pool)
  -        (%make-watcher-event-monitor watcher object event))))
  +  (let ((monitor (object-pool-pop *watcher-monitor-pool*)))
  +    (cond (monitor
  +           (setf (watcher-event-monitor-watcher monitor) watcher
  +                 (watcher-event-monitor-event monitor) event
  +                 (watcher-event-monitor-object monitor) object)
  +           monitor)
  +          (t
  +           (%make-watcher-event-monitor watcher object event)))))
   
   (defun unmake-watcher-event-monitor (monitor)
     ;; Don't leak objects.
  
positive.code: 
  (defun make-rw-lock (&optional name)
    (let ((rw-lock (%make-rw-lock name)))
      (setf (rw-lock-writer-wait-queue rw-lock) (make-wait-queue
                                                 :name (sys.int::cons-in-area
                                                        :writer
                                                        (sys.int::cons-in-area
                                                         rw-lock nil :wired)
                                                        :wired))
            (rw-lock-reader-wait-queue rw-lock) (make-wait-queue
                                                 :name (sys.int::cons-in-area
                                                        :reader
                                                        (sys.int::cons-in-area
                                                         rw-lock
                                                         nil
                                                         :wired)
                                                        :wired)))
      rw-lock))
  
  (defun rw-lock-read-acquire-slow (sp fp rw-lock)
  
negative.code:            (,timeout-sym ,timeout))
         (block nil
           (flet ((,predicate-fn () (progn ,@predicate)))
             (declare (dynamic-extent #',predicate-fn))
             (cond ((eql ,timeout-sym 0)
                    (values (,predicate-fn) 0))
                   (,timeout-sym
  