anchor.diff:  			     t
   			     (apply function arguments))))
     (<= timeout 0))
  -
  -(defmethod initialize-instance :after ((instance simple-process))
  -  (process-consider-runnability instance))
  -
  -(defmethod initialize-instance :after ((instance process) &key name stack-group
  -                                                            control-stack-size
  -                                                            data-stack-size
  -                                                            binding-stack-size
  -                                                            &allow-other-keys)
  -  (unless stack-group
  -    (setf (slot-value instance 'stack-group) (make-stack-group name
  -                                                               :control-stack-size control-stack-size
  -                                                               :data-stack-size data-stack-size
  -                                                               :binding-stack-size binding-stack-size)))
  -  (setf (slot-value instance 'initial-stack-group) (slot-value instance 'stack-group))
  -  (process-consider-runnability instance))
   
   (defun process-consider-runnability (process)
     (cond ((or (process-arrest-reasons process)
  
positive.code:        (let ((next-process (get-next-process *current-process*)))
           (setf *current-process* next-process)
           (cond (next-process
                  (if (typep next-process 'simple-process)
                      (with-simple-restart (abort "Return from ~S." next-process)
                        (%sti)
                        (apply (car (process-initial-form next-process))
                               (cdr (process-initial-form next-process))))
                      (progn
                        (stack-group-resume (process-stack-group next-process) nil)
                        (setf (process-stack-group next-process) (stack-group-resumer *scheduler-stack-group*)))))
                 (t (%stihlt)))))))
  
  (defun make-process (name &key stack-group
  
negative.code:                             run-reasons
                              arrest-reasons
                              whostate)
    (unless stack-group
      (setf stack-group (make-stack-group name
                                          :control-stack-size control-stack-size
                                          :data-stack-size data-stack-size
                                          :binding-stack-size binding-stack-size)))
    (let ((process (%make-process :name name
                                  :stack-group stack-group
                                  :initial-stack-group stack-group
                                  :run-reasons run-reasons
                                  :arrest-reasons arrest-reasons
                                  :whostate whostate)))
      (process-consider-runnability process)
      process))
  
  (defmacro with-process ((name function &rest arguments) &body body)
    (let ((x (gensym)))
  