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:            x))))
  
  (defun push (stack x &optional (hint 0))
    (with-mutex ((stack-lock stack))
      (vector-push-extend (bulk-task-hintify x hint)
                          (stack-data stack))))
  
  (defun push-all (stack values &optional (hint 0))
    (with-mutex ((stack-lock stack))
      (let ((data (stack-data stack)))
        (map nil (lambda (x)
                   (vector-push-extend (bulk-task-hintify x hint)
                                       data))
             values))))
  
  (defun steal (stack)
    (with-mutex ((stack-lock stack))
      (let ((data (stack-data stack)))
        (loop for i below (length data)
              for x = (aref data i)
              do (when (consp x)
                   (setf x (cdr x)))
                 (etypecase x
                   (null)
                   ((or symbol function task)
                    (shiftf (aref data i) nil)
                    (return x))
                   (bulk-task
                    (if (plusp (bulk-task-waiting x))
                        (return x)
                        (setf (aref data i) nil))))))))
  
  (declaim (inline bulk-find-task))
  (defun bulk-find-task (hint-and-bulk)
  
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)
  