anchor.diff:         (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*)))))
  +                (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
  
positive.code: 			     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)
  
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)))
  