anchor.diff:  
   (defstruct (task
               (:constructor nil))
  -  (fun (error "Missing arg") :type (or symbol function)))
  +  (function (error "Missing arg") :type (or symbol function)))
   
   (defstruct (bulk-task
               (:constructor nil))
  
positive.code:     ((or symbol function)
       (funcall task))
      (task
       (prog1 (funcall (task-fun task) task)
         (setf (task-fun task) nil)))))
  
  (defstruct stack
    (lock   (make-mutex) :type mutex
                         :read-only t)
    (data   (make-array 32 :fill-pointer 0 :adjustable t)
                         :type (and (not simple-vector)
                                    vector)
                         :read-only t))
  
  (defun make ()
    (make-stack))
  
  (declaim (inline p))
  (defun p (x)
    (stack-p x))
  
  ;; bulk tasks are represented, on-stack as conses: the CAR is a hint
  ;; wrt where to start looking for subtasks, and the CDR is the bulk-task
  
negative.code:                  (setf begin 0
                         end   hint))))))))
  
  (defun pop-one-task (stack)
    (declare (type stack stack))
    (loop
      (when (zerop (stack-top stack))
        (return nil))
      (multiple-value-bind (major minor) (split-index (stack-top stack))
        (let* ((stacklets (stack-stacklets stack))
               (stacklet  (aref stacklets major))
               (position  (position nil stacklet :from-end t :end minor :test-not #'eql)))
          (cond (position
                 (setf (stack-top stack) (+ (* major +stacklet-size+)
                                            position))
                 (let ((x (aref stacklet position)))
                   (etypecase x
                     (null)
                     (cons
                      (let ((bulk-task (cdr x)))
                        (when (and bulk-task
                                   (plusp (bulk-task-waiting bulk-task)))
                          (return x)))
                      (setf (cdr x) nil
                            (svref stacklet position) nil
                            (stack-top stack) (+ (* major +stacklet-size+)
                                                 position)))
                     ((or task symbol function)
                      (when (eql (cas (svref stacklet position) x nil) x)
                        (return x))))))
                ((zerop major)
                 (setf (stack-top stack) 0)
                 (return nil))
                (t
                 (setf (stack-top stack) (* major +stacklet-size+))))))))
  
  (defun run-one (stack)
    (let ((task (pop-one-task stack))
          subtask)
      (cond ((not task) nil)
            ((atom task)
  