carray 3.0.5 → 3.0.6

data/ext/carray_kernels_reduce_cumulative.c

@@ -98,14 +98,41 @@ accumulate_ki_stream_i8 (VALUE arg)
       return LL2NUM((int8_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} accumulate_ki_native_i8_frame;
+
 static VALUE
-accumulate_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+accumulate_ki_native_i8_body (VALUE arg)
 {
+  accumulate_ki_native_i8_frame *fr = (accumulate_ki_native_i8_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       accumulate_ki_stream_i8_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -126,7 +153,7 @@ accumulate_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
          && slab_axes[0] != (int8_t)(ca->ndim - 1)
          && ! ca_has_mask(ca)
          && ca_attach_is_alias(ca)
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_LOOP_INTERCHANGE) ) {
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
       ca_size_t __li_INNER = 1;
@@ -199,7 +226,7 @@ accumulate_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
          && ! ca_has_mask(ca)
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis == 0
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
@@ -227,7 +254,7 @@ accumulate_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const int8_t *p_root = (const int8_t *) __li_st->parents[__kk]->ptr;
           int8_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
@@ -287,7 +314,7 @@ accumulate_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
          && ((CAStack *) ca)->k_axis > 0
          && ( slab_axes[0] > ((CAStack *) ca)->k_axis
               || slab_axes[0] + 1 == ((CAStack *) ca)->k_axis )
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -344,7 +371,7 @@ accumulate_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const int8_t *p_root = (const int8_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -432,7 +459,7 @@ accumulate_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis > 0
          && slab_axes[0] + 1 < ((CAStack *) ca)->k_axis
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -504,7 +531,7 @@ accumulate_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const int8_t *p_root = (const int8_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -553,12 +580,41 @@ accumulate_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
         return vout;
       }
     }
+    if ( naxes == 1
+         && ca->ndim >= 2
+         && slab_axes[0] == (int8_t)(ca->ndim - 1)
+         && ca->dim[ca->ndim - 1] >= 1
+         && ca->dim[ca->ndim - 1] <= 32
+         && ! ca_has_mask(ca)
+         && ca_attach_is_alias(ca)
+         && ca_fast_path(CA_SC_SHORT_FIBER_REDUCE) ) {
+      ca_size_t __sf_M     = ca->dim[ca->ndim - 1];
+      ca_size_t __sf_OUTER = ca->elements / __sf_M;
+      VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT8, keep_axis);
+      CArray *co;
+      GetCArray(vout, co);
+      int8_t *op = (int8_t *) co->ptr;
+      ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
+      const int8_t *p_root = (const int8_t *) ca->ptr;
+      for ( ca_size_t __sf_o = 0; __sf_o < __sf_OUTER; __sf_o++ ) {
+        const int8_t *__sf_row = p_root + __sf_o * __sf_M;
+        int8_t acc = (int8_t) (0);
+        for ( ca_size_t __j = 0; __j < __sf_M; __j++ ) {
+          int8_t v = __sf_row[__j];
+          acc += v;
+          (void) v;
+        }
+
+        op[__sf_o] = (int8_t) (acc);
+      }
+      ca_detach(ca);
+      return vout;
+    }
   }
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT8, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 int8_t *op = (int8_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -592,7 +648,22 @@ ca_size_t   out_i = 0;
         return LL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+accumulate_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  accumulate_ki_native_i8_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, accumulate_ki_native_i8_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -647,14 +718,41 @@ accumulate_ki_stream_u8 (VALUE arg)
       return ULL2NUM((uint8_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} accumulate_ki_native_u8_frame;
+
 static VALUE
-accumulate_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+accumulate_ki_native_u8_body (VALUE arg)
 {
+  accumulate_ki_native_u8_frame *fr = (accumulate_ki_native_u8_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       accumulate_ki_stream_u8_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -675,7 +773,7 @@ accumulate_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
          && slab_axes[0] != (int8_t)(ca->ndim - 1)
          && ! ca_has_mask(ca)
          && ca_attach_is_alias(ca)
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_LOOP_INTERCHANGE) ) {
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
       ca_size_t __li_INNER = 1;
@@ -748,7 +846,7 @@ accumulate_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
          && ! ca_has_mask(ca)
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis == 0
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
@@ -776,7 +874,7 @@ accumulate_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const uint8_t *p_root = (const uint8_t *) __li_st->parents[__kk]->ptr;
           uint8_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
@@ -836,7 +934,7 @@ accumulate_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
          && ((CAStack *) ca)->k_axis > 0
          && ( slab_axes[0] > ((CAStack *) ca)->k_axis
               || slab_axes[0] + 1 == ((CAStack *) ca)->k_axis )
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -893,7 +991,7 @@ accumulate_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const uint8_t *p_root = (const uint8_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -981,7 +1079,7 @@ accumulate_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis > 0
          && slab_axes[0] + 1 < ((CAStack *) ca)->k_axis
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -1053,7 +1151,7 @@ accumulate_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const uint8_t *p_root = (const uint8_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -1102,12 +1200,41 @@ accumulate_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
         return vout;
       }
     }
+    if ( naxes == 1
+         && ca->ndim >= 2
+         && slab_axes[0] == (int8_t)(ca->ndim - 1)
+         && ca->dim[ca->ndim - 1] >= 1
+         && ca->dim[ca->ndim - 1] <= 32
+         && ! ca_has_mask(ca)
+         && ca_attach_is_alias(ca)
+         && ca_fast_path(CA_SC_SHORT_FIBER_REDUCE) ) {
+      ca_size_t __sf_M     = ca->dim[ca->ndim - 1];
+      ca_size_t __sf_OUTER = ca->elements / __sf_M;
+      VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT8, keep_axis);
+      CArray *co;
+      GetCArray(vout, co);
+      uint8_t *op = (uint8_t *) co->ptr;
+      ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
+      const uint8_t *p_root = (const uint8_t *) ca->ptr;
+      for ( ca_size_t __sf_o = 0; __sf_o < __sf_OUTER; __sf_o++ ) {
+        const uint8_t *__sf_row = p_root + __sf_o * __sf_M;
+        uint8_t acc = (uint8_t) (0);
+        for ( ca_size_t __j = 0; __j < __sf_M; __j++ ) {
+          uint8_t v = __sf_row[__j];
+          acc += v;
+          (void) v;
+        }
+
+        op[__sf_o] = (uint8_t) (acc);
+      }
+      ca_detach(ca);
+      return vout;
+    }
   }
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT8, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 uint8_t *op = (uint8_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -1141,7 +1268,22 @@ ca_size_t   out_i = 0;
         return ULL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+accumulate_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  accumulate_ki_native_u8_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, accumulate_ki_native_u8_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -1196,14 +1338,41 @@ accumulate_ki_stream_i16 (VALUE arg)
       return LL2NUM((ca_u_int16_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} accumulate_ki_native_i16_frame;
+
 static VALUE
-accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+accumulate_ki_native_i16_body (VALUE arg)
 {
+  accumulate_ki_native_i16_frame *fr = (accumulate_ki_native_i16_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       accumulate_ki_stream_i16_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -1224,7 +1393,7 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && slab_axes[0] != (int8_t)(ca->ndim - 1)
          && ! ca_has_mask(ca)
          && ca_attach_is_alias(ca)
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_LOOP_INTERCHANGE) ) {
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
       ca_size_t __li_INNER = 1;
@@ -1297,7 +1466,7 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ! ca_has_mask(ca)
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis == 0
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
@@ -1325,7 +1494,7 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_int16_t *p_root = (const ca_u_int16_t *) __li_st->parents[__kk]->ptr;
           ca_u_int16_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
@@ -1385,7 +1554,7 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ((CAStack *) ca)->k_axis > 0
          && ( slab_axes[0] > ((CAStack *) ca)->k_axis
               || slab_axes[0] + 1 == ((CAStack *) ca)->k_axis )
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -1442,7 +1611,7 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_int16_t *p_root = (const ca_u_int16_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -1530,7 +1699,7 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis > 0
          && slab_axes[0] + 1 < ((CAStack *) ca)->k_axis
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -1602,7 +1771,7 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_int16_t *p_root = (const ca_u_int16_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -1651,12 +1820,41 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         return vout;
       }
     }
+    if ( naxes == 1
+         && ca->ndim >= 2
+         && slab_axes[0] == (int8_t)(ca->ndim - 1)
+         && ca->dim[ca->ndim - 1] >= 1
+         && ca->dim[ca->ndim - 1] <= 32
+         && ! ca_has_mask(ca)
+         && ca_attach_is_alias(ca)
+         && ca_fast_path(CA_SC_SHORT_FIBER_REDUCE) ) {
+      ca_size_t __sf_M     = ca->dim[ca->ndim - 1];
+      ca_size_t __sf_OUTER = ca->elements / __sf_M;
+      VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT16, keep_axis);
+      CArray *co;
+      GetCArray(vout, co);
+      ca_u_int16_t *op = (ca_u_int16_t *) co->ptr;
+      ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
+      const ca_u_int16_t *p_root = (const ca_u_int16_t *) ca->ptr;
+      for ( ca_size_t __sf_o = 0; __sf_o < __sf_OUTER; __sf_o++ ) {
+        const ca_u_int16_t *__sf_row = p_root + __sf_o * __sf_M;
+        ca_u_int16_t acc = (ca_u_int16_t) (0);
+        for ( ca_size_t __j = 0; __j < __sf_M; __j++ ) {
+          ca_u_int16_t v = __sf_row[__j];
+          acc += v;
+          (void) v;
+        }
+
+        op[__sf_o] = (ca_u_int16_t) (acc);
+      }
+      ca_detach(ca);
+      return vout;
+    }
   }
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT16, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_int16_t *op = (ca_u_int16_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -1690,7 +1888,22 @@ ca_size_t   out_i = 0;
         return LL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  accumulate_ki_native_i16_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, accumulate_ki_native_i16_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -1745,14 +1958,41 @@ accumulate_ki_stream_u16 (VALUE arg)
       return ULL2NUM((ca_u_uint16_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} accumulate_ki_native_u16_frame;
+
 static VALUE
-accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+accumulate_ki_native_u16_body (VALUE arg)
 {
+  accumulate_ki_native_u16_frame *fr = (accumulate_ki_native_u16_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       accumulate_ki_stream_u16_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -1773,7 +2013,7 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && slab_axes[0] != (int8_t)(ca->ndim - 1)
          && ! ca_has_mask(ca)
          && ca_attach_is_alias(ca)
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_LOOP_INTERCHANGE) ) {
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
       ca_size_t __li_INNER = 1;
@@ -1846,7 +2086,7 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ! ca_has_mask(ca)
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis == 0
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
@@ -1874,7 +2114,7 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_uint16_t *p_root = (const ca_u_uint16_t *) __li_st->parents[__kk]->ptr;
           ca_u_uint16_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
@@ -1934,7 +2174,7 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ((CAStack *) ca)->k_axis > 0
          && ( slab_axes[0] > ((CAStack *) ca)->k_axis
               || slab_axes[0] + 1 == ((CAStack *) ca)->k_axis )
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -1991,7 +2231,7 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_uint16_t *p_root = (const ca_u_uint16_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -2079,7 +2319,7 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis > 0
          && slab_axes[0] + 1 < ((CAStack *) ca)->k_axis
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -2151,7 +2391,7 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_uint16_t *p_root = (const ca_u_uint16_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -2200,12 +2440,41 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         return vout;
       }
     }
+    if ( naxes == 1
+         && ca->ndim >= 2
+         && slab_axes[0] == (int8_t)(ca->ndim - 1)
+         && ca->dim[ca->ndim - 1] >= 1
+         && ca->dim[ca->ndim - 1] <= 32
+         && ! ca_has_mask(ca)
+         && ca_attach_is_alias(ca)
+         && ca_fast_path(CA_SC_SHORT_FIBER_REDUCE) ) {
+      ca_size_t __sf_M     = ca->dim[ca->ndim - 1];
+      ca_size_t __sf_OUTER = ca->elements / __sf_M;
+      VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT16, keep_axis);
+      CArray *co;
+      GetCArray(vout, co);
+      ca_u_uint16_t *op = (ca_u_uint16_t *) co->ptr;
+      ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
+      const ca_u_uint16_t *p_root = (const ca_u_uint16_t *) ca->ptr;
+      for ( ca_size_t __sf_o = 0; __sf_o < __sf_OUTER; __sf_o++ ) {
+        const ca_u_uint16_t *__sf_row = p_root + __sf_o * __sf_M;
+        ca_u_uint16_t acc = (ca_u_uint16_t) (0);
+        for ( ca_size_t __j = 0; __j < __sf_M; __j++ ) {
+          ca_u_uint16_t v = __sf_row[__j];
+          acc += v;
+          (void) v;
+        }
+
+        op[__sf_o] = (ca_u_uint16_t) (acc);
+      }
+      ca_detach(ca);
+      return vout;
+    }
   }
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT16, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_uint16_t *op = (ca_u_uint16_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -2239,7 +2508,22 @@ ca_size_t   out_i = 0;
         return ULL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  accumulate_ki_native_u16_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, accumulate_ki_native_u16_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -2294,14 +2578,41 @@ accumulate_ki_stream_i32 (VALUE arg)
       return LL2NUM((ca_u_int32_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} accumulate_ki_native_i32_frame;
+
 static VALUE
-accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+accumulate_ki_native_i32_body (VALUE arg)
 {
+  accumulate_ki_native_i32_frame *fr = (accumulate_ki_native_i32_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       accumulate_ki_stream_i32_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -2322,7 +2633,7 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && slab_axes[0] != (int8_t)(ca->ndim - 1)
          && ! ca_has_mask(ca)
          && ca_attach_is_alias(ca)
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_LOOP_INTERCHANGE) ) {
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
       ca_size_t __li_INNER = 1;
@@ -2395,7 +2706,7 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ! ca_has_mask(ca)
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis == 0
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
@@ -2423,7 +2734,7 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_int32_t *p_root = (const ca_u_int32_t *) __li_st->parents[__kk]->ptr;
           ca_u_int32_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
@@ -2483,7 +2794,7 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ((CAStack *) ca)->k_axis > 0
          && ( slab_axes[0] > ((CAStack *) ca)->k_axis
               || slab_axes[0] + 1 == ((CAStack *) ca)->k_axis )
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -2540,7 +2851,7 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_int32_t *p_root = (const ca_u_int32_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -2628,7 +2939,7 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis > 0
          && slab_axes[0] + 1 < ((CAStack *) ca)->k_axis
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -2700,7 +3011,7 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_int32_t *p_root = (const ca_u_int32_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -2749,12 +3060,41 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         return vout;
       }
     }
+    if ( naxes == 1
+         && ca->ndim >= 2
+         && slab_axes[0] == (int8_t)(ca->ndim - 1)
+         && ca->dim[ca->ndim - 1] >= 1
+         && ca->dim[ca->ndim - 1] <= 32
+         && ! ca_has_mask(ca)
+         && ca_attach_is_alias(ca)
+         && ca_fast_path(CA_SC_SHORT_FIBER_REDUCE) ) {
+      ca_size_t __sf_M     = ca->dim[ca->ndim - 1];
+      ca_size_t __sf_OUTER = ca->elements / __sf_M;
+      VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT32, keep_axis);
+      CArray *co;
+      GetCArray(vout, co);
+      ca_u_int32_t *op = (ca_u_int32_t *) co->ptr;
+      ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
+      const ca_u_int32_t *p_root = (const ca_u_int32_t *) ca->ptr;
+      for ( ca_size_t __sf_o = 0; __sf_o < __sf_OUTER; __sf_o++ ) {
+        const ca_u_int32_t *__sf_row = p_root + __sf_o * __sf_M;
+        ca_u_int32_t acc = (ca_u_int32_t) (0);
+        for ( ca_size_t __j = 0; __j < __sf_M; __j++ ) {
+          ca_u_int32_t v = __sf_row[__j];
+          acc += v;
+          (void) v;
+        }
+
+        op[__sf_o] = (ca_u_int32_t) (acc);
+      }
+      ca_detach(ca);
+      return vout;
+    }
   }
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT32, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_int32_t *op = (ca_u_int32_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -2788,7 +3128,22 @@ ca_size_t   out_i = 0;
         return LL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  accumulate_ki_native_i32_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, accumulate_ki_native_i32_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -2843,21 +3198,48 @@ accumulate_ki_stream_u32 (VALUE arg)
       return ULL2NUM((ca_u_uint32_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} accumulate_ki_native_u32_frame;
+
 static VALUE
-accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+accumulate_ki_native_u32_body (VALUE arg)
 {
-    if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
-         ca->elements > 0 &&
-         ! ca_too_few_present(ca->elements, min_count, 0) &&
-         ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
-      accumulate_ki_stream_u32_t __ctx;
-      __ctx.chunk = NULL;
-      __ctx.ca    = ca;
-      __ctx.min_count = min_count;
-      return ca_lazy_arena_protect(accumulate_ki_stream_u32, ca_lazy_arena_release_held,
-                                   (VALUE) &__ctx);
-    }
+  accumulate_ki_native_u32_frame *fr = (accumulate_ki_native_u32_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
+    if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
+         ca->elements > 0 &&
+         ! ca_too_few_present(ca->elements, min_count, 0) &&
+         ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
+      accumulate_ki_stream_u32_t __ctx;
+      __ctx.chunk = NULL;
+      __ctx.ca    = ca;
+      __ctx.min_count = min_count;
+      return ca_lazy_arena_protect(accumulate_ki_stream_u32, ca_lazy_arena_release_held,
+                                   (VALUE) &__ctx);
+    }
   if ( naxes != 1 || ! ca_too_few_present(ca->dim[slab_axes[0]], min_count, 0) ) {
     /* L.1 / L.7: loop-interchange fast path with inner-tiling
        (PROPOSAL_REDUCTION_LOOP_INTERCHANGE).
@@ -2871,7 +3253,7 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && slab_axes[0] != (int8_t)(ca->ndim - 1)
          && ! ca_has_mask(ca)
          && ca_attach_is_alias(ca)
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_LOOP_INTERCHANGE) ) {
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
       ca_size_t __li_INNER = 1;
@@ -2944,7 +3326,7 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ! ca_has_mask(ca)
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis == 0
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
@@ -2972,7 +3354,7 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_uint32_t *p_root = (const ca_u_uint32_t *) __li_st->parents[__kk]->ptr;
           ca_u_uint32_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
@@ -3032,7 +3414,7 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ((CAStack *) ca)->k_axis > 0
          && ( slab_axes[0] > ((CAStack *) ca)->k_axis
               || slab_axes[0] + 1 == ((CAStack *) ca)->k_axis )
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -3089,7 +3471,7 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_uint32_t *p_root = (const ca_u_uint32_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -3177,7 +3559,7 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis > 0
          && slab_axes[0] + 1 < ((CAStack *) ca)->k_axis
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -3249,7 +3631,7 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_uint32_t *p_root = (const ca_u_uint32_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -3298,12 +3680,41 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         return vout;
       }
     }
+    if ( naxes == 1
+         && ca->ndim >= 2
+         && slab_axes[0] == (int8_t)(ca->ndim - 1)
+         && ca->dim[ca->ndim - 1] >= 1
+         && ca->dim[ca->ndim - 1] <= 32
+         && ! ca_has_mask(ca)
+         && ca_attach_is_alias(ca)
+         && ca_fast_path(CA_SC_SHORT_FIBER_REDUCE) ) {
+      ca_size_t __sf_M     = ca->dim[ca->ndim - 1];
+      ca_size_t __sf_OUTER = ca->elements / __sf_M;
+      VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT32, keep_axis);
+      CArray *co;
+      GetCArray(vout, co);
+      ca_u_uint32_t *op = (ca_u_uint32_t *) co->ptr;
+      ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
+      const ca_u_uint32_t *p_root = (const ca_u_uint32_t *) ca->ptr;
+      for ( ca_size_t __sf_o = 0; __sf_o < __sf_OUTER; __sf_o++ ) {
+        const ca_u_uint32_t *__sf_row = p_root + __sf_o * __sf_M;
+        ca_u_uint32_t acc = (ca_u_uint32_t) (0);
+        for ( ca_size_t __j = 0; __j < __sf_M; __j++ ) {
+          ca_u_uint32_t v = __sf_row[__j];
+          acc += v;
+          (void) v;
+        }
+
+        op[__sf_o] = (ca_u_uint32_t) (acc);
+      }
+      ca_detach(ca);
+      return vout;
+    }
   }
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT32, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_uint32_t *op = (ca_u_uint32_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -3337,7 +3748,22 @@ ca_size_t   out_i = 0;
         return ULL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  accumulate_ki_native_u32_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, accumulate_ki_native_u32_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -3392,14 +3818,41 @@ accumulate_ki_stream_i64 (VALUE arg)
       return LL2NUM((ca_u_int64_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} accumulate_ki_native_i64_frame;
+
 static VALUE
-accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+accumulate_ki_native_i64_body (VALUE arg)
 {
+  accumulate_ki_native_i64_frame *fr = (accumulate_ki_native_i64_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       accumulate_ki_stream_i64_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -3420,7 +3873,7 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && slab_axes[0] != (int8_t)(ca->ndim - 1)
          && ! ca_has_mask(ca)
          && ca_attach_is_alias(ca)
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_LOOP_INTERCHANGE) ) {
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
       ca_size_t __li_INNER = 1;
@@ -3493,7 +3946,7 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ! ca_has_mask(ca)
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis == 0
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
@@ -3521,7 +3974,7 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_int64_t *p_root = (const ca_u_int64_t *) __li_st->parents[__kk]->ptr;
           ca_u_int64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
@@ -3581,7 +4034,7 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ((CAStack *) ca)->k_axis > 0
          && ( slab_axes[0] > ((CAStack *) ca)->k_axis
               || slab_axes[0] + 1 == ((CAStack *) ca)->k_axis )
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -3638,7 +4091,7 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_int64_t *p_root = (const ca_u_int64_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -3726,7 +4179,7 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis > 0
          && slab_axes[0] + 1 < ((CAStack *) ca)->k_axis
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -3798,7 +4251,7 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_int64_t *p_root = (const ca_u_int64_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -3847,12 +4300,41 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         return vout;
       }
     }
+    if ( naxes == 1
+         && ca->ndim >= 2
+         && slab_axes[0] == (int8_t)(ca->ndim - 1)
+         && ca->dim[ca->ndim - 1] >= 1
+         && ca->dim[ca->ndim - 1] <= 32
+         && ! ca_has_mask(ca)
+         && ca_attach_is_alias(ca)
+         && ca_fast_path(CA_SC_SHORT_FIBER_REDUCE) ) {
+      ca_size_t __sf_M     = ca->dim[ca->ndim - 1];
+      ca_size_t __sf_OUTER = ca->elements / __sf_M;
+      VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
+      CArray *co;
+      GetCArray(vout, co);
+      ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
+      ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
+      const ca_u_int64_t *p_root = (const ca_u_int64_t *) ca->ptr;
+      for ( ca_size_t __sf_o = 0; __sf_o < __sf_OUTER; __sf_o++ ) {
+        const ca_u_int64_t *__sf_row = p_root + __sf_o * __sf_M;
+        ca_u_int64_t acc = (ca_u_int64_t) (0);
+        for ( ca_size_t __j = 0; __j < __sf_M; __j++ ) {
+          ca_u_int64_t v = __sf_row[__j];
+          acc += v;
+          (void) v;
+        }
+
+        op[__sf_o] = (ca_u_int64_t) (acc);
+      }
+      ca_detach(ca);
+      return vout;
+    }
   }
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -3886,7 +4368,22 @@ ca_size_t   out_i = 0;
         return LL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  accumulate_ki_native_i64_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, accumulate_ki_native_i64_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -3941,14 +4438,41 @@ accumulate_ki_stream_u64 (VALUE arg)
       return ULL2NUM((ca_u_uint64_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} accumulate_ki_native_u64_frame;
+
 static VALUE
-accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+accumulate_ki_native_u64_body (VALUE arg)
 {
+  accumulate_ki_native_u64_frame *fr = (accumulate_ki_native_u64_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       accumulate_ki_stream_u64_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -3969,7 +4493,7 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && slab_axes[0] != (int8_t)(ca->ndim - 1)
          && ! ca_has_mask(ca)
          && ca_attach_is_alias(ca)
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_LOOP_INTERCHANGE) ) {
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
       ca_size_t __li_INNER = 1;
@@ -4042,7 +4566,7 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ! ca_has_mask(ca)
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis == 0
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
@@ -4070,7 +4594,7 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_uint64_t *p_root = (const ca_u_uint64_t *) __li_st->parents[__kk]->ptr;
           ca_u_uint64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
@@ -4130,7 +4654,7 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ((CAStack *) ca)->k_axis > 0
          && ( slab_axes[0] > ((CAStack *) ca)->k_axis
               || slab_axes[0] + 1 == ((CAStack *) ca)->k_axis )
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -4187,7 +4711,7 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_uint64_t *p_root = (const ca_u_uint64_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -4275,7 +4799,7 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis > 0
          && slab_axes[0] + 1 < ((CAStack *) ca)->k_axis
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -4347,7 +4871,7 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_uint64_t *p_root = (const ca_u_uint64_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -4396,12 +4920,41 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         return vout;
       }
     }
+    if ( naxes == 1
+         && ca->ndim >= 2
+         && slab_axes[0] == (int8_t)(ca->ndim - 1)
+         && ca->dim[ca->ndim - 1] >= 1
+         && ca->dim[ca->ndim - 1] <= 32
+         && ! ca_has_mask(ca)
+         && ca_attach_is_alias(ca)
+         && ca_fast_path(CA_SC_SHORT_FIBER_REDUCE) ) {
+      ca_size_t __sf_M     = ca->dim[ca->ndim - 1];
+      ca_size_t __sf_OUTER = ca->elements / __sf_M;
+      VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT64, keep_axis);
+      CArray *co;
+      GetCArray(vout, co);
+      ca_u_uint64_t *op = (ca_u_uint64_t *) co->ptr;
+      ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
+      const ca_u_uint64_t *p_root = (const ca_u_uint64_t *) ca->ptr;
+      for ( ca_size_t __sf_o = 0; __sf_o < __sf_OUTER; __sf_o++ ) {
+        const ca_u_uint64_t *__sf_row = p_root + __sf_o * __sf_M;
+        ca_u_uint64_t acc = (ca_u_uint64_t) (0);
+        for ( ca_size_t __j = 0; __j < __sf_M; __j++ ) {
+          ca_u_uint64_t v = __sf_row[__j];
+          acc += v;
+          (void) v;
+        }
+
+        op[__sf_o] = (ca_u_uint64_t) (acc);
+      }
+      ca_detach(ca);
+      return vout;
+    }
   }
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_uint64_t *op = (ca_u_uint64_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -4435,7 +4988,22 @@ ca_size_t   out_i = 0;
         return ULL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  accumulate_ki_native_u64_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, accumulate_ki_native_u64_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -4490,14 +5058,41 @@ accumulate_ki_stream_f32 (VALUE arg)
       return rb_float_new((ca_u_float32_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} accumulate_ki_native_f32_frame;
+
 static VALUE
-accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+accumulate_ki_native_f32_body (VALUE arg)
 {
+  accumulate_ki_native_f32_frame *fr = (accumulate_ki_native_f32_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       accumulate_ki_stream_f32_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -4518,7 +5113,7 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && slab_axes[0] != (int8_t)(ca->ndim - 1)
          && ! ca_has_mask(ca)
          && ca_attach_is_alias(ca)
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_LOOP_INTERCHANGE) ) {
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
       ca_size_t __li_INNER = 1;
@@ -4591,7 +5186,7 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ! ca_has_mask(ca)
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis == 0
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
@@ -4619,7 +5214,7 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_float32_t *p_root = (const ca_u_float32_t *) __li_st->parents[__kk]->ptr;
           ca_u_float32_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
@@ -4679,7 +5274,7 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ((CAStack *) ca)->k_axis > 0
          && ( slab_axes[0] > ((CAStack *) ca)->k_axis
               || slab_axes[0] + 1 == ((CAStack *) ca)->k_axis )
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -4736,7 +5331,7 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_float32_t *p_root = (const ca_u_float32_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -4824,7 +5419,7 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis > 0
          && slab_axes[0] + 1 < ((CAStack *) ca)->k_axis
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -4896,7 +5491,7 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_float32_t *p_root = (const ca_u_float32_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -4945,12 +5540,41 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         return vout;
       }
     }
+    if ( naxes == 1
+         && ca->ndim >= 2
+         && slab_axes[0] == (int8_t)(ca->ndim - 1)
+         && ca->dim[ca->ndim - 1] >= 1
+         && ca->dim[ca->ndim - 1] <= 32
+         && ! ca_has_mask(ca)
+         && ca_attach_is_alias(ca)
+         && ca_fast_path(CA_SC_SHORT_FIBER_REDUCE) ) {
+      ca_size_t __sf_M     = ca->dim[ca->ndim - 1];
+      ca_size_t __sf_OUTER = ca->elements / __sf_M;
+      VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT32, keep_axis);
+      CArray *co;
+      GetCArray(vout, co);
+      ca_u_float32_t *op = (ca_u_float32_t *) co->ptr;
+      ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
+      const ca_u_float32_t *p_root = (const ca_u_float32_t *) ca->ptr;
+      for ( ca_size_t __sf_o = 0; __sf_o < __sf_OUTER; __sf_o++ ) {
+        const ca_u_float32_t *__sf_row = p_root + __sf_o * __sf_M;
+        ca_u_float32_t acc = (ca_u_float32_t) (0);
+        for ( ca_size_t __j = 0; __j < __sf_M; __j++ ) {
+          ca_u_float32_t v = __sf_row[__j];
+          acc += v;
+          (void) v;
+        }
+
+        op[__sf_o] = (ca_u_float32_t) (acc);
+      }
+      ca_detach(ca);
+      return vout;
+    }
   }
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT32, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_float32_t *op = (ca_u_float32_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -4984,7 +5608,22 @@ ca_size_t   out_i = 0;
         return rb_float_new(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  accumulate_ki_native_f32_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, accumulate_ki_native_f32_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -5039,14 +5678,41 @@ accumulate_ki_stream_f64 (VALUE arg)
       return rb_float_new((ca_u_float64_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} accumulate_ki_native_f64_frame;
+
 static VALUE
-accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+accumulate_ki_native_f64_body (VALUE arg)
 {
+  accumulate_ki_native_f64_frame *fr = (accumulate_ki_native_f64_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       accumulate_ki_stream_f64_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -5067,7 +5733,7 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && slab_axes[0] != (int8_t)(ca->ndim - 1)
          && ! ca_has_mask(ca)
          && ca_attach_is_alias(ca)
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_LOOP_INTERCHANGE) ) {
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
       ca_size_t __li_INNER = 1;
@@ -5140,7 +5806,7 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ! ca_has_mask(ca)
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis == 0
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
@@ -5168,7 +5834,7 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_float64_t *p_root = (const ca_u_float64_t *) __li_st->parents[__kk]->ptr;
           ca_u_float64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
@@ -5228,7 +5894,7 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ((CAStack *) ca)->k_axis > 0
          && ( slab_axes[0] > ((CAStack *) ca)->k_axis
               || slab_axes[0] + 1 == ((CAStack *) ca)->k_axis )
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -5285,7 +5951,7 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_float64_t *p_root = (const ca_u_float64_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -5373,7 +6039,7 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis > 0
          && slab_axes[0] + 1 < ((CAStack *) ca)->k_axis
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -5445,7 +6111,7 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_float64_t *p_root = (const ca_u_float64_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -5494,12 +6160,41 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         return vout;
       }
     }
+    if ( naxes == 1
+         && ca->ndim >= 2
+         && slab_axes[0] == (int8_t)(ca->ndim - 1)
+         && ca->dim[ca->ndim - 1] >= 1
+         && ca->dim[ca->ndim - 1] <= 32
+         && ! ca_has_mask(ca)
+         && ca_attach_is_alias(ca)
+         && ca_fast_path(CA_SC_SHORT_FIBER_REDUCE) ) {
+      ca_size_t __sf_M     = ca->dim[ca->ndim - 1];
+      ca_size_t __sf_OUTER = ca->elements / __sf_M;
+      VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+      CArray *co;
+      GetCArray(vout, co);
+      ca_u_float64_t *op = (ca_u_float64_t *) co->ptr;
+      ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
+      const ca_u_float64_t *p_root = (const ca_u_float64_t *) ca->ptr;
+      for ( ca_size_t __sf_o = 0; __sf_o < __sf_OUTER; __sf_o++ ) {
+        const ca_u_float64_t *__sf_row = p_root + __sf_o * __sf_M;
+        ca_u_float64_t acc = (ca_u_float64_t) (0);
+        for ( ca_size_t __j = 0; __j < __sf_M; __j++ ) {
+          ca_u_float64_t v = __sf_row[__j];
+          acc += v;
+          (void) v;
+        }
+
+        op[__sf_o] = (ca_u_float64_t) (acc);
+      }
+      ca_detach(ca);
+      return vout;
+    }
   }
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_float64_t *op = (ca_u_float64_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -5533,7 +6228,22 @@ ca_size_t   out_i = 0;
         return rb_float_new(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  accumulate_ki_native_f64_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, accumulate_ki_native_f64_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -5588,20 +6298,47 @@ accumulate_ki_stream_cmplx64 (VALUE arg)
       return CC2NUM((ca_u_cmplx64_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} accumulate_ki_native_cmplx64_frame;
+
 static VALUE
-accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+accumulate_ki_native_cmplx64_body (VALUE arg)
 {
-    if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
-         ca->elements > 0 &&
-         ! ca_too_few_present(ca->elements, min_count, 0) &&
-         ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
-      accumulate_ki_stream_cmplx64_t __ctx;
-      __ctx.chunk = NULL;
-      __ctx.ca    = ca;
-      __ctx.min_count = min_count;
-      return ca_lazy_arena_protect(accumulate_ki_stream_cmplx64, ca_lazy_arena_release_held,
-                                   (VALUE) &__ctx);
+  accumulate_ki_native_cmplx64_frame *fr = (accumulate_ki_native_cmplx64_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
+    if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
+         ca->elements > 0 &&
+         ! ca_too_few_present(ca->elements, min_count, 0) &&
+         ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
+      accumulate_ki_stream_cmplx64_t __ctx;
+      __ctx.chunk = NULL;
+      __ctx.ca    = ca;
+      __ctx.min_count = min_count;
+      return ca_lazy_arena_protect(accumulate_ki_stream_cmplx64, ca_lazy_arena_release_held,
+                                   (VALUE) &__ctx);
     }
   if ( naxes != 1 || ! ca_too_few_present(ca->dim[slab_axes[0]], min_count, 0) ) {
     /* L.1 / L.7: loop-interchange fast path with inner-tiling
@@ -5616,7 +6353,7 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
          && slab_axes[0] != (int8_t)(ca->ndim - 1)
          && ! ca_has_mask(ca)
          && ca_attach_is_alias(ca)
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_LOOP_INTERCHANGE) ) {
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
       ca_size_t __li_INNER = 1;
@@ -5689,7 +6426,7 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
          && ! ca_has_mask(ca)
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis == 0
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
@@ -5717,7 +6454,7 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_cmplx64_t *p_root = (const ca_u_cmplx64_t *) __li_st->parents[__kk]->ptr;
           ca_u_cmplx64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
@@ -5777,7 +6514,7 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
          && ((CAStack *) ca)->k_axis > 0
          && ( slab_axes[0] > ((CAStack *) ca)->k_axis
               || slab_axes[0] + 1 == ((CAStack *) ca)->k_axis )
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -5834,7 +6571,7 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_cmplx64_t *p_root = (const ca_u_cmplx64_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -5922,7 +6659,7 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis > 0
          && slab_axes[0] + 1 < ((CAStack *) ca)->k_axis
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -5994,7 +6731,7 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_cmplx64_t *p_root = (const ca_u_cmplx64_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -6043,12 +6780,41 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
         return vout;
       }
     }
+    if ( naxes == 1
+         && ca->ndim >= 2
+         && slab_axes[0] == (int8_t)(ca->ndim - 1)
+         && ca->dim[ca->ndim - 1] >= 1
+         && ca->dim[ca->ndim - 1] <= 32
+         && ! ca_has_mask(ca)
+         && ca_attach_is_alias(ca)
+         && ca_fast_path(CA_SC_SHORT_FIBER_REDUCE) ) {
+      ca_size_t __sf_M     = ca->dim[ca->ndim - 1];
+      ca_size_t __sf_OUTER = ca->elements / __sf_M;
+      VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_CMPLX64, keep_axis);
+      CArray *co;
+      GetCArray(vout, co);
+      ca_u_cmplx64_t *op = (ca_u_cmplx64_t *) co->ptr;
+      ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
+      const ca_u_cmplx64_t *p_root = (const ca_u_cmplx64_t *) ca->ptr;
+      for ( ca_size_t __sf_o = 0; __sf_o < __sf_OUTER; __sf_o++ ) {
+        const ca_u_cmplx64_t *__sf_row = p_root + __sf_o * __sf_M;
+        ca_u_cmplx64_t acc = (ca_u_cmplx64_t) (0);
+        for ( ca_size_t __j = 0; __j < __sf_M; __j++ ) {
+          ca_u_cmplx64_t v = __sf_row[__j];
+          acc += v;
+          (void) v;
+        }
+
+        op[__sf_o] = (ca_u_cmplx64_t) (acc);
+      }
+      ca_detach(ca);
+      return vout;
+    }
   }
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_CMPLX64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_cmplx64_t *op = (ca_u_cmplx64_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -6082,7 +6848,22 @@ ca_size_t   out_i = 0;
         return CC2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  accumulate_ki_native_cmplx64_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, accumulate_ki_native_cmplx64_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -6137,14 +6918,41 @@ accumulate_ki_stream_cmplx128 (VALUE arg)
       return CC2NUM((ca_u_cmplx128_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} accumulate_ki_native_cmplx128_frame;
+
 static VALUE
-accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+accumulate_ki_native_cmplx128_body (VALUE arg)
 {
+  accumulate_ki_native_cmplx128_frame *fr = (accumulate_ki_native_cmplx128_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       accumulate_ki_stream_cmplx128_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -6165,7 +6973,7 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
          && slab_axes[0] != (int8_t)(ca->ndim - 1)
          && ! ca_has_mask(ca)
          && ca_attach_is_alias(ca)
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_LOOP_INTERCHANGE) ) {
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
       ca_size_t __li_INNER = 1;
@@ -6238,7 +7046,7 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
          && ! ca_has_mask(ca)
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis == 0
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
@@ -6266,7 +7074,7 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_cmplx128_t *p_root = (const ca_u_cmplx128_t *) __li_st->parents[__kk]->ptr;
           ca_u_cmplx128_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
@@ -6326,7 +7134,7 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
          && ((CAStack *) ca)->k_axis > 0
          && ( slab_axes[0] > ((CAStack *) ca)->k_axis
               || slab_axes[0] + 1 == ((CAStack *) ca)->k_axis )
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -6383,7 +7191,7 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_cmplx128_t *p_root = (const ca_u_cmplx128_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -6471,7 +7279,7 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis > 0
          && slab_axes[0] + 1 < ((CAStack *) ca)->k_axis
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -6543,7 +7351,7 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const ca_u_cmplx128_t *p_root = (const ca_u_cmplx128_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -6592,12 +7400,41 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
         return vout;
       }
     }
+    if ( naxes == 1
+         && ca->ndim >= 2
+         && slab_axes[0] == (int8_t)(ca->ndim - 1)
+         && ca->dim[ca->ndim - 1] >= 1
+         && ca->dim[ca->ndim - 1] <= 32
+         && ! ca_has_mask(ca)
+         && ca_attach_is_alias(ca)
+         && ca_fast_path(CA_SC_SHORT_FIBER_REDUCE) ) {
+      ca_size_t __sf_M     = ca->dim[ca->ndim - 1];
+      ca_size_t __sf_OUTER = ca->elements / __sf_M;
+      VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_CMPLX128, keep_axis);
+      CArray *co;
+      GetCArray(vout, co);
+      ca_u_cmplx128_t *op = (ca_u_cmplx128_t *) co->ptr;
+      ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
+      const ca_u_cmplx128_t *p_root = (const ca_u_cmplx128_t *) ca->ptr;
+      for ( ca_size_t __sf_o = 0; __sf_o < __sf_OUTER; __sf_o++ ) {
+        const ca_u_cmplx128_t *__sf_row = p_root + __sf_o * __sf_M;
+        ca_u_cmplx128_t acc = (ca_u_cmplx128_t) (0);
+        for ( ca_size_t __j = 0; __j < __sf_M; __j++ ) {
+          ca_u_cmplx128_t v = __sf_row[__j];
+          acc += v;
+          (void) v;
+        }
+
+        op[__sf_o] = (ca_u_cmplx128_t) (acc);
+      }
+      ca_detach(ca);
+      return vout;
+    }
   }
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_CMPLX128, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_cmplx128_t *op = (ca_u_cmplx128_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -6631,7 +7468,22 @@ ca_size_t   out_i = 0;
         return CC2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  accumulate_ki_native_cmplx128_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, accumulate_ki_native_cmplx128_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -6686,14 +7538,41 @@ accumulate_ki_stream_bool (VALUE arg)
       return INT2NUM((boolean8_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} accumulate_ki_native_bool_frame;
+
 static VALUE
-accumulate_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+accumulate_ki_native_bool_body (VALUE arg)
 {
+  accumulate_ki_native_bool_frame *fr = (accumulate_ki_native_bool_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       accumulate_ki_stream_bool_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -6714,7 +7593,7 @@ accumulate_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
          && slab_axes[0] != (int8_t)(ca->ndim - 1)
          && ! ca_has_mask(ca)
          && ca_attach_is_alias(ca)
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_LOOP_INTERCHANGE) ) {
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
       ca_size_t __li_INNER = 1;
@@ -6787,7 +7666,7 @@ accumulate_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
          && ! ca_has_mask(ca)
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis == 0
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
@@ -6815,7 +7694,7 @@ accumulate_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const boolean8_t *p_root = (const boolean8_t *) __li_st->parents[__kk]->ptr;
           boolean8_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
@@ -6875,7 +7754,7 @@ accumulate_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
          && ((CAStack *) ca)->k_axis > 0
          && ( slab_axes[0] > ((CAStack *) ca)->k_axis
               || slab_axes[0] + 1 == ((CAStack *) ca)->k_axis )
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -6932,7 +7811,7 @@ accumulate_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const boolean8_t *p_root = (const boolean8_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -7020,7 +7899,7 @@ accumulate_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis > 0
          && slab_axes[0] + 1 < ((CAStack *) ca)->k_axis
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -7092,7 +7971,7 @@ accumulate_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const boolean8_t *p_root = (const boolean8_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -7141,12 +8020,41 @@ accumulate_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
         return vout;
       }
     }
+    if ( naxes == 1
+         && ca->ndim >= 2
+         && slab_axes[0] == (int8_t)(ca->ndim - 1)
+         && ca->dim[ca->ndim - 1] >= 1
+         && ca->dim[ca->ndim - 1] <= 32
+         && ! ca_has_mask(ca)
+         && ca_attach_is_alias(ca)
+         && ca_fast_path(CA_SC_SHORT_FIBER_REDUCE) ) {
+      ca_size_t __sf_M     = ca->dim[ca->ndim - 1];
+      ca_size_t __sf_OUTER = ca->elements / __sf_M;
+      VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_BOOLEAN, keep_axis);
+      CArray *co;
+      GetCArray(vout, co);
+      boolean8_t *op = (boolean8_t *) co->ptr;
+      ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
+      const boolean8_t *p_root = (const boolean8_t *) ca->ptr;
+      for ( ca_size_t __sf_o = 0; __sf_o < __sf_OUTER; __sf_o++ ) {
+        const boolean8_t *__sf_row = p_root + __sf_o * __sf_M;
+        boolean8_t acc = (boolean8_t) (0);
+        for ( ca_size_t __j = 0; __j < __sf_M; __j++ ) {
+          boolean8_t v = __sf_row[__j];
+          acc ^= v;
+          (void) v;
+        }
+
+        op[__sf_o] = (boolean8_t) (acc);
+      }
+      ca_detach(ca);
+      return vout;
+    }
   }
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_BOOLEAN, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 boolean8_t *op = (boolean8_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -7178,7 +8086,22 @@ ca_size_t   out_i = 0;
         return INT2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+accumulate_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  accumulate_ki_native_bool_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, accumulate_ki_native_bool_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -7233,9 +8156,9 @@ accumulate_ki_stream_object (VALUE arg)
       return (VALUE)((VALUE) (acc));
 }
 
-/* The object lane calls Ruby for every cell, so a walk can raise part
-   way.  Its states live in the caller's frame, and ca_iter_ensure
-   finishes them however the body leaves. */
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
 typedef struct {
   ca_iter_state states[1];
   VALUE self;
@@ -7267,7 +8190,7 @@ accumulate_ki_native_object_body (VALUE arg)
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       accumulate_ki_stream_object_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -7323,7 +8246,7 @@ accumulate_ki_native_object (VALUE self, CArray *ca, int8_t *slab_axes, int8_t n
   fr.naxes = naxes;
   fr.keep_axis = keep_axis;
   fr.min_count = min_count;
-  return ca_iter_ensure(1, fr.states, accumulate_ki_native_object_body, (VALUE) &fr);
+  return ca_iter_ensure_computing(ca, 1, fr.states, accumulate_ki_native_object_body, (VALUE) &fr);
 }
 
 
@@ -7492,14 +8415,41 @@ count_true_ki_stream_bool (VALUE arg)
       return LL2NUM((ca_u_int64_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} count_true_ki_native_bool_frame;
+
 static VALUE
-count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+count_true_ki_native_bool_body (VALUE arg)
 {
+  count_true_ki_native_bool_frame *fr = (count_true_ki_native_bool_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       count_true_ki_stream_bool_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -7520,7 +8470,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
          && slab_axes[0] != (int8_t)(ca->ndim - 1)
          && ! ca_has_mask(ca)
          && ca_attach_is_alias(ca)
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_LOOP_INTERCHANGE) ) {
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
       ca_size_t __li_INNER = 1;
@@ -7593,7 +8543,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
          && ! ca_has_mask(ca)
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis == 0
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
@@ -7621,7 +8571,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const boolean8_t *p_root = (const boolean8_t *) __li_st->parents[__kk]->ptr;
           ca_u_int64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
@@ -7681,7 +8631,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
          && ((CAStack *) ca)->k_axis > 0
          && ( slab_axes[0] > ((CAStack *) ca)->k_axis
               || slab_axes[0] + 1 == ((CAStack *) ca)->k_axis )
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -7738,7 +8688,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const boolean8_t *p_root = (const boolean8_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -7826,7 +8776,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis > 0
          && slab_axes[0] + 1 < ((CAStack *) ca)->k_axis
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -7898,7 +8848,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const boolean8_t *p_root = (const boolean8_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -7947,12 +8897,41 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
         return vout;
       }
     }
+    if ( naxes == 1
+         && ca->ndim >= 2
+         && slab_axes[0] == (int8_t)(ca->ndim - 1)
+         && ca->dim[ca->ndim - 1] >= 1
+         && ca->dim[ca->ndim - 1] <= 32
+         && ! ca_has_mask(ca)
+         && ca_attach_is_alias(ca)
+         && ca_fast_path(CA_SC_SHORT_FIBER_REDUCE) ) {
+      ca_size_t __sf_M     = ca->dim[ca->ndim - 1];
+      ca_size_t __sf_OUTER = ca->elements / __sf_M;
+      VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
+      CArray *co;
+      GetCArray(vout, co);
+      ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
+      ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
+      const boolean8_t *p_root = (const boolean8_t *) ca->ptr;
+      for ( ca_size_t __sf_o = 0; __sf_o < __sf_OUTER; __sf_o++ ) {
+        const boolean8_t *__sf_row = p_root + __sf_o * __sf_M;
+        ca_u_int64_t acc = (ca_u_int64_t) (0);
+        for ( ca_size_t __j = 0; __j < __sf_M; __j++ ) {
+          boolean8_t v = __sf_row[__j];
+          acc += v;
+          (void) v;
+        }
+
+        op[__sf_o] = (ca_u_int64_t) (acc);
+      }
+      ca_detach(ca);
+      return vout;
+    }
   }
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -7986,7 +8965,22 @@ ca_size_t   out_i = 0;
         return LL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  count_true_ki_native_bool_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, count_true_ki_native_bool_body, (VALUE) &fr);
+}
+
 
 VALUE
 rb_ca_count_true_ki (int argc, VALUE *argv, VALUE self)
@@ -8088,14 +9082,41 @@ count_false_ki_stream_bool (VALUE arg)
       return LL2NUM((ca_u_int64_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} count_false_ki_native_bool_frame;
+
 static VALUE
-count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+count_false_ki_native_bool_body (VALUE arg)
 {
+  count_false_ki_native_bool_frame *fr = (count_false_ki_native_bool_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       count_false_ki_stream_bool_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -8116,7 +9137,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
          && slab_axes[0] != (int8_t)(ca->ndim - 1)
          && ! ca_has_mask(ca)
          && ca_attach_is_alias(ca)
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_LOOP_INTERCHANGE) ) {
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
       ca_size_t __li_INNER = 1;
@@ -8189,7 +9210,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
          && ! ca_has_mask(ca)
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis == 0
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       ca_size_t __li_M     = ca->dim[__li_ax];
@@ -8217,7 +9238,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const boolean8_t *p_root = (const boolean8_t *) __li_st->parents[__kk]->ptr;
           ca_u_int64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
@@ -8277,7 +9298,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
          && ((CAStack *) ca)->k_axis > 0
          && ( slab_axes[0] > ((CAStack *) ca)->k_axis
               || slab_axes[0] + 1 == ((CAStack *) ca)->k_axis )
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -8334,7 +9355,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const boolean8_t *p_root = (const boolean8_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -8422,7 +9443,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
          && ca_func[ca->obj_type].attach == ca_stack_func.attach
          && ((CAStack *) ca)->k_axis > 0
          && slab_axes[0] + 1 < ((CAStack *) ca)->k_axis
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_LOOP_INTERCHANGE) ) {
       CAStack  *__li_st    = (CAStack *) ca;
       int8_t    __li_ax    = slab_axes[0];
       int8_t    __li_kax   = (int8_t) __li_st->k_axis;
@@ -8494,7 +9515,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
-          ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
+          ca_attach(__li_st->parents[__kk]);   /* window: a parent may run Ruby to fill itself (a CAObject's copy_data); a raising attach holds nothing and the earlier parents are already detached, and the numeric loop after it does not raise */
           const boolean8_t *p_root = (const boolean8_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
@@ -8543,12 +9564,41 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
         return vout;
       }
     }
+    if ( naxes == 1
+         && ca->ndim >= 2
+         && slab_axes[0] == (int8_t)(ca->ndim - 1)
+         && ca->dim[ca->ndim - 1] >= 1
+         && ca->dim[ca->ndim - 1] <= 32
+         && ! ca_has_mask(ca)
+         && ca_attach_is_alias(ca)
+         && ca_fast_path(CA_SC_SHORT_FIBER_REDUCE) ) {
+      ca_size_t __sf_M     = ca->dim[ca->ndim - 1];
+      ca_size_t __sf_OUTER = ca->elements / __sf_M;
+      VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
+      CArray *co;
+      GetCArray(vout, co);
+      ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
+      ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
+      const boolean8_t *p_root = (const boolean8_t *) ca->ptr;
+      for ( ca_size_t __sf_o = 0; __sf_o < __sf_OUTER; __sf_o++ ) {
+        const boolean8_t *__sf_row = p_root + __sf_o * __sf_M;
+        ca_u_int64_t acc = (ca_u_int64_t) (0);
+        for ( ca_size_t __j = 0; __j < __sf_M; __j++ ) {
+          boolean8_t v = __sf_row[__j];
+          acc += !v;
+          (void) v;
+        }
+
+        op[__sf_o] = (ca_u_int64_t) (acc);
+      }
+      ca_detach(ca);
+      return vout;
+    }
   }
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -8580,7 +9630,22 @@ ca_size_t   out_i = 0;
         return LL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  count_false_ki_native_bool_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, count_false_ki_native_bool_body, (VALUE) &fr);
+}
+
 
 VALUE
 rb_ca_count_false_ki (int argc, VALUE *argv, VALUE self)
@@ -8685,27 +9750,56 @@ count_equal_ki_stream_i8 (VALUE arg)
       return LL2NUM((ca_u_int64_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  int8_t value_arg;
+  ca_size_t min_count;
+} count_equal_ki_native_i8_frame;
+
 static VALUE
-count_equal_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, int8_t value_arg, ca_size_t min_count)
+count_equal_ki_native_i8_body (VALUE arg)
 {
-    if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
-         ca->elements > 0 &&
-         ! ca_too_few_present(ca->elements, min_count, 0) &&
-         ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
-      count_equal_ki_stream_i8_t __ctx;
-      __ctx.chunk = NULL;
-      __ctx.ca    = ca;
-      __ctx.value_arg = value_arg;
-      __ctx.min_count = min_count;
-      return ca_lazy_arena_protect(count_equal_ki_stream_i8, ca_lazy_arena_release_held,
+  count_equal_ki_native_i8_frame *fr = (count_equal_ki_native_i8_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  int8_t value_arg = fr->value_arg;
+  (void) value_arg;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
+    if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
+         ca->elements > 0 &&
+         ! ca_too_few_present(ca->elements, min_count, 0) &&
+         ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
+      count_equal_ki_stream_i8_t __ctx;
+      __ctx.chunk = NULL;
+      __ctx.ca    = ca;
+      __ctx.value_arg = value_arg;
+      __ctx.min_count = min_count;
+      return ca_lazy_arena_protect(count_equal_ki_stream_i8, ca_lazy_arena_release_held,
                                    (VALUE) &__ctx);
     }
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -8737,7 +9831,23 @@ ca_size_t   out_i = 0;
         return LL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+count_equal_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, int8_t value_arg, ca_size_t min_count)
+{
+  count_equal_ki_native_i8_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.value_arg = value_arg;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, count_equal_ki_native_i8_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -8795,14 +9905,44 @@ count_equal_ki_stream_u8 (VALUE arg)
       return LL2NUM((ca_u_int64_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  uint8_t value_arg;
+  ca_size_t min_count;
+} count_equal_ki_native_u8_frame;
+
 static VALUE
-count_equal_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, uint8_t value_arg, ca_size_t min_count)
+count_equal_ki_native_u8_body (VALUE arg)
 {
+  count_equal_ki_native_u8_frame *fr = (count_equal_ki_native_u8_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  uint8_t value_arg = fr->value_arg;
+  (void) value_arg;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       count_equal_ki_stream_u8_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -8815,7 +9955,6 @@ VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -8847,7 +9986,23 @@ ca_size_t   out_i = 0;
         return LL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+count_equal_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, uint8_t value_arg, ca_size_t min_count)
+{
+  count_equal_ki_native_u8_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.value_arg = value_arg;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, count_equal_ki_native_u8_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -8905,14 +10060,44 @@ count_equal_ki_stream_i16 (VALUE arg)
       return LL2NUM((ca_u_int64_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_u_int16_t value_arg;
+  ca_size_t min_count;
+} count_equal_ki_native_i16_frame;
+
 static VALUE
-count_equal_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_int16_t value_arg, ca_size_t min_count)
+count_equal_ki_native_i16_body (VALUE arg)
 {
+  count_equal_ki_native_i16_frame *fr = (count_equal_ki_native_i16_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_u_int16_t value_arg = fr->value_arg;
+  (void) value_arg;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       count_equal_ki_stream_i16_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -8925,7 +10110,6 @@ VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -8957,7 +10141,23 @@ ca_size_t   out_i = 0;
         return LL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+count_equal_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_int16_t value_arg, ca_size_t min_count)
+{
+  count_equal_ki_native_i16_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.value_arg = value_arg;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, count_equal_ki_native_i16_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -9015,14 +10215,44 @@ count_equal_ki_stream_u16 (VALUE arg)
       return LL2NUM((ca_u_int64_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_u_uint16_t value_arg;
+  ca_size_t min_count;
+} count_equal_ki_native_u16_frame;
+
 static VALUE
-count_equal_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_uint16_t value_arg, ca_size_t min_count)
+count_equal_ki_native_u16_body (VALUE arg)
 {
+  count_equal_ki_native_u16_frame *fr = (count_equal_ki_native_u16_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_u_uint16_t value_arg = fr->value_arg;
+  (void) value_arg;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       count_equal_ki_stream_u16_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -9035,7 +10265,6 @@ VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -9067,7 +10296,23 @@ ca_size_t   out_i = 0;
         return LL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+count_equal_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_uint16_t value_arg, ca_size_t min_count)
+{
+  count_equal_ki_native_u16_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.value_arg = value_arg;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, count_equal_ki_native_u16_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -9125,14 +10370,44 @@ count_equal_ki_stream_i32 (VALUE arg)
       return LL2NUM((ca_u_int64_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_u_int32_t value_arg;
+  ca_size_t min_count;
+} count_equal_ki_native_i32_frame;
+
 static VALUE
-count_equal_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_int32_t value_arg, ca_size_t min_count)
+count_equal_ki_native_i32_body (VALUE arg)
 {
+  count_equal_ki_native_i32_frame *fr = (count_equal_ki_native_i32_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_u_int32_t value_arg = fr->value_arg;
+  (void) value_arg;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       count_equal_ki_stream_i32_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -9145,7 +10420,6 @@ VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -9177,7 +10451,23 @@ ca_size_t   out_i = 0;
         return LL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+count_equal_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_int32_t value_arg, ca_size_t min_count)
+{
+  count_equal_ki_native_i32_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.value_arg = value_arg;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, count_equal_ki_native_i32_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -9235,14 +10525,44 @@ count_equal_ki_stream_u32 (VALUE arg)
       return LL2NUM((ca_u_int64_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_u_uint32_t value_arg;
+  ca_size_t min_count;
+} count_equal_ki_native_u32_frame;
+
 static VALUE
-count_equal_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_uint32_t value_arg, ca_size_t min_count)
+count_equal_ki_native_u32_body (VALUE arg)
 {
+  count_equal_ki_native_u32_frame *fr = (count_equal_ki_native_u32_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_u_uint32_t value_arg = fr->value_arg;
+  (void) value_arg;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       count_equal_ki_stream_u32_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -9255,7 +10575,6 @@ VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -9287,7 +10606,23 @@ ca_size_t   out_i = 0;
         return LL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+count_equal_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_uint32_t value_arg, ca_size_t min_count)
+{
+  count_equal_ki_native_u32_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.value_arg = value_arg;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, count_equal_ki_native_u32_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -9345,14 +10680,44 @@ count_equal_ki_stream_i64 (VALUE arg)
       return LL2NUM((ca_u_int64_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_u_int64_t value_arg;
+  ca_size_t min_count;
+} count_equal_ki_native_i64_frame;
+
 static VALUE
-count_equal_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_int64_t value_arg, ca_size_t min_count)
+count_equal_ki_native_i64_body (VALUE arg)
 {
+  count_equal_ki_native_i64_frame *fr = (count_equal_ki_native_i64_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_u_int64_t value_arg = fr->value_arg;
+  (void) value_arg;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       count_equal_ki_stream_i64_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -9365,7 +10730,6 @@ VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -9397,7 +10761,23 @@ ca_size_t   out_i = 0;
         return LL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+count_equal_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_int64_t value_arg, ca_size_t min_count)
+{
+  count_equal_ki_native_i64_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.value_arg = value_arg;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, count_equal_ki_native_i64_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -9455,14 +10835,44 @@ count_equal_ki_stream_u64 (VALUE arg)
       return LL2NUM((ca_u_int64_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_u_uint64_t value_arg;
+  ca_size_t min_count;
+} count_equal_ki_native_u64_frame;
+
 static VALUE
-count_equal_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_uint64_t value_arg, ca_size_t min_count)
+count_equal_ki_native_u64_body (VALUE arg)
 {
+  count_equal_ki_native_u64_frame *fr = (count_equal_ki_native_u64_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_u_uint64_t value_arg = fr->value_arg;
+  (void) value_arg;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       count_equal_ki_stream_u64_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -9475,7 +10885,6 @@ VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -9507,7 +10916,23 @@ ca_size_t   out_i = 0;
         return LL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+count_equal_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_uint64_t value_arg, ca_size_t min_count)
+{
+  count_equal_ki_native_u64_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.value_arg = value_arg;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, count_equal_ki_native_u64_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -9565,14 +10990,44 @@ count_equal_ki_stream_f32 (VALUE arg)
       return LL2NUM((ca_u_int64_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_u_float32_t value_arg;
+  ca_size_t min_count;
+} count_equal_ki_native_f32_frame;
+
 static VALUE
-count_equal_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_float32_t value_arg, ca_size_t min_count)
+count_equal_ki_native_f32_body (VALUE arg)
 {
+  count_equal_ki_native_f32_frame *fr = (count_equal_ki_native_f32_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_u_float32_t value_arg = fr->value_arg;
+  (void) value_arg;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       count_equal_ki_stream_f32_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -9585,7 +11040,6 @@ VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -9617,7 +11071,23 @@ ca_size_t   out_i = 0;
         return LL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+count_equal_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_float32_t value_arg, ca_size_t min_count)
+{
+  count_equal_ki_native_f32_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.value_arg = value_arg;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, count_equal_ki_native_f32_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -9675,14 +11145,44 @@ count_equal_ki_stream_f64 (VALUE arg)
       return LL2NUM((ca_u_int64_t) (acc));
 }
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_u_float64_t value_arg;
+  ca_size_t min_count;
+} count_equal_ki_native_f64_frame;
+
 static VALUE
-count_equal_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_float64_t value_arg, ca_size_t min_count)
+count_equal_ki_native_f64_body (VALUE arg)
 {
+  count_equal_ki_native_f64_frame *fr = (count_equal_ki_native_f64_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_u_float64_t value_arg = fr->value_arg;
+  (void) value_arg;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       count_equal_ki_stream_f64_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -9695,7 +11195,6 @@ VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
 ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
-ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -9727,7 +11226,23 @@ ca_size_t   out_i = 0;
         return LL2NUM(op[0]);
       }
       return vout;
-    }
+#undef st
+}
+
+static VALUE
+count_equal_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_float64_t value_arg, ca_size_t min_count)
+{
+  count_equal_ki_native_f64_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.value_arg = value_arg;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, count_equal_ki_native_f64_body, (VALUE) &fr);
+}
+
 
 typedef struct {
   void      *chunk;
@@ -9785,9 +11300,9 @@ count_equal_ki_stream_object (VALUE arg)
       return LL2NUM((ca_u_int64_t) (acc));
 }
 
-/* The object lane calls Ruby for every cell, so a walk can raise part
-   way.  Its states live in the caller's frame, and ca_iter_ensure
-   finishes them however the body leaves. */
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
 typedef struct {
   ca_iter_state states[1];
   VALUE self;
@@ -9822,7 +11337,7 @@ count_equal_ki_native_object_body (VALUE arg)
          ca->elements > 0 &&
          ! ca_too_few_present(ca->elements, min_count, 0) &&
          ca_is_lazy_view(ca) && ! ca_has_mask(ca) &&
-         ca_fast_paths_enabled() ) {
+         ca_fast_path(CA_SC_LAZY_STREAMING_REDUCE) ) {
       count_equal_ki_stream_object_t __ctx;
       __ctx.chunk = NULL;
       __ctx.ca    = ca;
@@ -9880,19 +11395,48 @@ count_equal_ki_native_object (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
   fr.keep_axis = keep_axis;
   fr.value_arg = value_arg;
   fr.min_count = min_count;
-  return ca_iter_ensure(1, fr.states, count_equal_ki_native_object_body, (VALUE) &fr);
+  return ca_iter_ensure_computing(ca, 1, fr.states, count_equal_ki_native_object_body, (VALUE) &fr);
 }
 
 
+/* The walks can raise part way (a Ruby call per cell in the object
+   lane, an allocation in any lane).  Their states live in the caller's
+   frame, and ca_iter_ensure finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  const char *value_arg;
+  ca_size_t min_count;
+} count_equal_ki_native_fixlen_frame;
+
 static VALUE
-count_equal_ki_native_fixlen (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, const char *value_arg, ca_size_t min_count)
+count_equal_ki_native_fixlen_body (VALUE arg)
 {
+  count_equal_ki_native_fixlen_frame *fr = (count_equal_ki_native_fixlen_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  const char *value_arg = fr->value_arg;
+  (void) value_arg;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
   ca_size_t K = ca->bytes;   /* uniform fixlen byte width */
   VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
   CArray *co;
   GetCArray(vout, co);
   char       *op = (char *) co->ptr;
-  ca_iter_state st;
   int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES, slab_axes, naxes, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError, "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
@@ -9949,8 +11493,24 @@ count_equal_ki_native_fixlen (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
     return LL2NUM(((int64_t *) op)[0]);
   }
   return vout;
+#undef st
 }
 
+static VALUE
+count_equal_ki_native_fixlen (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, const char *value_arg, ca_size_t min_count)
+{
+  count_equal_ki_native_fixlen_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.value_arg = value_arg;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, count_equal_ki_native_fixlen_body, (VALUE) &fr);
+}
+
+
 VALUE
 rb_ca_count_equal_ki (int argc, VALUE *argv, VALUE self)
 {