anchor.diff:      `(let* ((,%cloud ,cloud)
               (,%hidden-chunk-size (chunk-size (hidden-chunk ,%cloud))))
          (declare (type index ,%hidden-chunk-size))
  -       (assert (= 1 (chunk-n-stripes (visible-chunk ,%cloud))))
  +       (check-stripes (visible-chunk ,%cloud))
          (do-stripes ((visible-chunk ,%cloud))
            (do-chunk (,visible-index (visible-chunk ,%cloud))
              (let ((,%offset (the! index
  
positive.code:          (shared (factored-cloud-shared-chunk cloud))
           (v* (storage v))
           (shared* (storage (nodes shared))))
      (with-segment-gradient-accumulator ((start accumulator accumulator2)
                                          ((cloud-a cloud) trainer))
        (when (and accumulator start)
  
negative.code:             (ignore-errors (chunk-max-n-stripes chunk))))
    chunk)
  
  ;;; Currently the lisp code handles only the single stripe case and
  ;;; blas cannot deal with no missing values.
  (defun check-stripes (chunk)
    (let ((indices-present (indices-present chunk)))
      (assert (or (null indices-present)
                  (= 1 (chunk-n-stripes chunk))))))
  
  (defun use-blas-on-chunk-p (cost chunk)
    (check-stripes chunk)
    (cond ((indices-present chunk)
           ;; there is no missing value support in blas
           nil)
          (t
           ;; several stripes or cost is high => blas
           (or (< 1 (chunk-n-stripes chunk))
               (use-blas-p cost)))))
  
  (defun ->chunk (chunk-designator chunks)
    (if (typep chunk-designator 'chunk)
  