anchor.diff:    (with-kernel-slots (worker-info) kernel
       (with-worker-info-slots (bindings name) worker-info
         (let* ((worker (%make-worker index tasks))
  -             (worker-thread (with-thread (:bindings bindings :name name)
  +             (all-bindings (make-all-bindings kernel bindings))
  +             (worker-thread (with-thread (:bindings all-bindings :name name)
                                 (unwind-protect/ext
                                  :prepare (handshake/from-worker worker)
                                  :main    (enter-worker-loop kernel worker)
  
positive.code: the number of task-searching iterations done by the worker before
  sleeping."
    (check-type worker-count (integer 1 #.most-positive-fixnum))
    (let* ((bindings (nconc (copy-alist bindings)
                            (list (cons '*debugger-hook* *debugger-hook*))
                            (copy-alist *kernel-thread-locals*)))
           (worker-info (make-worker-info-instance
                         :bindings bindings
                         :context context
                         :name name))
           (workers (make-array worker-count))
           (kernel (make-kernel-instance
                    :scheduler (make-scheduler workers spin-count)
                    :workers workers
                    :workers-lock (make-lock)
                    :worker-info worker-info
                    :optimizer-data (make-optimizer-data *optimizer*))))
      (with-kernel-slots (workers worker-info) kernel
        (with-worker-info-slots (bindings) worker-info
          (push (cons '*kernel* kernel) bindings)
          (let1 index 0
            (map-into workers
                      (lambda ()
                        (make-worker kernel
                                     (prog1 index (incf index))
                                     (make-spin-queue))))
            (dosequence (worker workers)
              (handshake/to-worker worker)))))
      kernel))
  
  (defun check-kernel ()
  
negative.code:        context
         kernel))))
  
  (defun make-all-bindings (kernel bindings)
    (append bindings
            (list (cons '*kernel* kernel))
            *kernel-thread-locals*))
  
  #+lparallel.with-stealing-scheduler
  (defun %make-worker (index tasks)
    (make-worker-instance :thread nil :index index :tasks tasks))
  