anchor.diff:  (defmethod print-object ((chunk chunk) stream)
     (format stream "~@<#<~;~S ~_~@{~S ~:_~S~^ ~_~}~;>~:>"
             (class-name (class-of chunk))
  +          :shape (chunk-shape chunk)
             :buffer (chunk-buffer chunk)
  -          :shape (chunk-shape chunk)
             :split (chunk-split chunk)))
   
   (defun chunk-bits (chunk)
  
positive.code:   "Attempt to split CHUNK at the supplied AXIS and POSITION.  If the split
  could be introduced successfully, or if an equivalent split already
  existed, return that split.  Otherwise, return NIL."
    (unless (not axis)
      (alexandria:if-let (split (chunk-split chunk))
        ;; Attempt to reuse an existing split.
        (let* ((split-axis (split-axis split))
               (split-position (split-position split))
               (split-range (shape-range (chunk-shape chunk) split-axis)))
          (when (and (= split-axis axis)
                     (< (abs (- split-position position))
                        (range-step split-range)))
            split))
        ;; Ensure that the CHUNK has a priority that is sufficiently high.
        (when (>= (chunk-split-priority chunk) *chunk-split-min-priority*)
          (let* ((buffer (chunk-buffer chunk))
                 (ghostspec (buffer-ghostspec buffer))
                 (left-padding (ghostspec-left-padding ghostspec axis))
                 (right-padding (ghostspec-right-padding ghostspec axis)))
            ;; Ensure that the ghostspec permits splitting at that axis.
            (when (and left-padding right-padding)
              (multiple-value-bind (left-shape right-shape)
                  (split-shape (chunk-shape chunk) axis position)
                ;; Ensure the split won't introduce too many ghost layers.
                (when (and (< right-padding
                              (* *chunk-split-max-redundancy*
                                 (range-size (shape-range left-shape axis))))
                           (< left-padding
                              (* *chunk-split-max-redundancy*
                                 (range-size (shape-range right-shape axis)))))
                  ;; Success!
                  (let* ((left-child (make-chunk :buffer buffer :shape left-shape :parent chunk))
                         (right-child (make-chunk :buffer buffer :shape right-shape :parent chunk))
                         (split (make-split
                                 :parent chunk
                                 :axis axis
                                 :left-child left-child
                                 :right-child right-child)))
                    (enqueue-chunk left-child)
                    (enqueue-chunk right-child)
                    (push split *unpropagated-splits*)
                    (setf (chunk-split chunk) split)
                    split)))))))))
  
  (defun chunk-split-axis (chunk)
    "Returns the axis where chunk can be split while introducing the minimum
  
negative.code:                (- position 1/2))
              (if (or (not axis1)
                      (let ((range (shape-range iteration-space axis1)))
                        (not (and (< (range-start range) position1)
                                  (<= position1 (range-last range))))))
                  (push writer boring-writers)
                  (let ((left-chunks '())
                        (right-chunks '()))
  