anchor.diff:                   (setf begin 0
                          end   hint))))))))
   
  -(defun get-one-task (stack)
  -  (with-mutex ((stack-lock stack))
  -    (let ((data (stack-data stack)))
  -      (loop
  -        (let* ((index (position nil data :from-end t
  -                                         :test-not #'eql))
  -               (task  (and index (aref data index))))
  -          (flet ((clear ()
  -                   (setf (aref data index)   nil
  -                         (fill-pointer data) index)))
  -            (declare (inline clear))
  -            (etypecase task
  -              (null
  -               (setf (fill-pointer data) 0)
  +(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))
  -              (cons
  -               (let ((bulk-task (cdr task)))
  -                 (when (and bulk-task
  -                            (plusp (bulk-task-waiting bulk-task)))
  -                   (return task))
  -                 (clear)))
  -              ((or task symbol function)
  -               (clear)
  -               (return task)))))))))
  +              (t
  +               (setf (stack-top stack) (* major +stacklet-size+))))))))
   
   (defun run-one (stack)
  -  (let ((task (get-one-task stack))
  +  (let ((task (pop-one-task stack))
           subtask)
       (cond ((not task) nil)
             ((atom task)
  
positive.code: 
  (defstruct (task
              (:constructor nil))
    (fun (error "Missing arg") :type (or symbol function)))
  
  (defstruct (bulk-task
              (:constructor nil))
  
negative.code:            x))))
  
  (defun push (stack x &optional (hint 0))
    (%push stack (bulk-task-hintify x hint)))
  
  (defun push-all (stack values &optional (hint 0))
    (map nil (lambda (x)
               (%push stack (bulk-task-hintify x hint)))
         values))
  
  (declaim (inline bulk-find-task))
  (defun bulk-find-task (hint-and-bulk)
  