anchor.diff:      (push `(,kernel ,load) (buffer-readers source-buffer))
       (push `(,kernel ,store) (buffer-writers target-buffer))
       kernel))
  +
  +;;; Compute an alist whose keys are shapes and whose values are dendrites
  +;;; that are covered by that shape.  Ensure that the dendrites of each
  +;;; cover a reasonable portion of that shape.  We use an empirically
  +;;; determined heuristic to decide which dendrites are to be grouped in one
  +;;; entry.
  +(defun partition-dendrites (dendrites)
  +  (let ((alist '()))
  +    (loop for dendrite in dendrites do
  +      (block convert-one-dendrite
  +        (let ((dshape (dendrite-shape dendrite)))
  +          (loop for entry in alist do
  +            (let* ((eshape (car entry))
  +                   (cover (fuse-shapes eshape dshape)))
  +              (when (<= (* (shape-size cover) 0.75)
  +                        (+ (shape-size dshape)
  +                           (shape-size eshape)))
  +                (setf (car entry) cover)
  +                (push dendrite (cdr entry))
  +                (return-from convert-one-dendrite)))
  +                finally (push `(,dshape ,dendrite) alist)))))
  +    alist))
   
   (defmethod convert-cluster
       ((cluster cluster)
  
positive.code:          (setf (dendrite-depth dendrite)
                 (lazy-array-depth non-immediate))
           (grow-dendrite dendrite non-immediate)
           (unless (null other-dendrites)
             (if (instructionp (cdr cons))
                 (loop for other-dendrite in other-dendrites do
  
negative.code: (defmethod convert-cluster
      ((cluster cluster)
       (non-immediate non-immediate))
    (let ((alist (partition-dendrites (cluster-dendrites cluster)))
          (buffers '()))
      (loop for (shape . mergeable-dendrites) in alist do
        (let ((buffer (make-buffer :shape shape :ntype (cluster-ntype cluster))))
          (push buffer buffers)
  