anchor.diff:      ;; immediately at cluster conversion time.
       (loop for (cons . other-conses) in (ir-converter-cons-updates *ir-converter*) do
         (let ((instruction (cdr cons)))
  -        (assert (instructionp instruction))
  -        (loop for other-cons in other-conses do
  -          (setf (cdr other-cons) instruction))))
  +        ;; The cdr might not contain an instruction if the corresponding
  +        ;; dendrite has been invalidated in the meantime.
  +        (when (instructionp instruction)
  +          (loop for other-cons in other-conses do
  +            (setf (cdr other-cons) instruction)))))
       (finalize-ir root-buffers)
       (nreverse root-buffers)))
   
  
positive.code:   ;; is no need to keep the current cluster in the cluster table.  No new
    ;; dendrites will ever reach it.
    (remhash non-immediate (ir-converter-cluster-table *ir-converter*))
    ;; Now we remove all invalid dendrites.  Recall that dendrites can become
    ;; invalid if they, or another dendrite with the same stem, reach more
    ;; than one input of a lazy fuse array.
    (let ((valid-dendrites (remove-if-not #'dendrite-validp (cluster-dendrites cluster))))
      (setf (cluster-dendrites cluster) valid-dendrites)
      (cond
        ;; If there are zero valid dendrites, the cluster can be ignored
        ((null valid-dendrites)
         (values))
        ;; If all dendrites have the same stem, shape, and transformation,
        ;; there is no need to convert this cluster at all.  We can simply
        ;; continue growing from here.
        ((and (petalisp.utilities:identical valid-dendrites :test #'mergeable-dendrites-p)
              (transformation-invertiblep (dendrite-transformation (first valid-dendrites))))
         (let* ((dendrite (first valid-dendrites))
                (other-dendrites (rest valid-dendrites))
                (cons (dendrite-cons dendrite)))
           (setf (dendrite-depth dendrite)
                 (lazy-array-depth non-immediate))
           (grow-dendrite dendrite non-immediate)
           ;; After growing, it is important to copy the next instruction to
           ;; the cons cells of all abandoned dendrites.  If the instruction
           ;; is known right after growing, this can be done immediately.
           ;; Otherwise, the copying is postponed to a later pass.
           (unless (null other-dendrites)
             (if (instructionp (cdr cons))
                 (loop for other-dendrite in other-dendrites do
                   (setf (cdr (dendrite-cons other-dendrite))
                         (cdr cons)))
                 (push (list* cons (mapcar #'dendrite-cons other-dendrites))
                       (ir-converter-cons-updates *ir-converter*))))))
        ;; Otherwise, actually convert the cluster.
        (t (call-next-method)))))
  
  (defun mergeable-dendrites-p (d1 d2)
    (and (eq
          (dendrite-stem d1)
          (dendrite-stem d2))
         (shape-equal
          (dendrite-shape d1)
          (dendrite-shape d2))
         (transformation-equal
          (dendrite-transformation d1)
          (dendrite-transformation d2))))
  
negative.code: 
  ;;; Compute an alist whose keys are shapes and whose values are dendrites
  ;;; that are covered by that shape.  Ensure that the dendrites of each
  ;;; entry 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)
  