RubyGems - carray - Versions diffs - 3.0.5 → 3.0.6 - Mend

carray 3.0.5 → 3.0.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (119) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +233 -0
data/README.md +1 -1
data/carray.gemspec +3 -2
data/ext/ca_axis_dispatch.c +6 -0
data/ext/ca_axis_group.c +1 -1
data/ext/ca_categorical_iterator.c +7 -7
data/ext/ca_kernel_iterator.c +116 -231
data/ext/ca_kernel_iterator.h +410 -254
data/ext/ca_obj_bincmp.c +9 -1
data/ext/ca_obj_binop.c +10 -1
data/ext/ca_obj_bitfield.c +2 -0
data/ext/ca_obj_byte_swap.c +2 -0
data/ext/ca_obj_face.c +2 -0
data/ext/ca_obj_fake.c +3 -1
data/ext/ca_obj_grid.c +167 -12
data/ext/ca_obj_meld.c +69 -113
data/ext/ca_obj_moncmp.c +9 -1
data/ext/ca_obj_monop.c +40 -2
data/ext/ca_obj_object.c +54 -20
data/ext/ca_obj_reduce.c +15 -1
data/ext/ca_obj_refer.c +65 -20
data/ext/ca_obj_remap.c +69 -10
data/ext/ca_obj_roll.c +1 -0
data/ext/ca_obj_select.c +4 -1
data/ext/ca_obj_select_axis.c +1 -0
data/ext/ca_obj_shift.c +1 -0
data/ext/ca_obj_stack.c +310 -111
data/ext/ca_obj_stride.c +131 -45
data/ext/ca_obj_string.c +18 -2
data/ext/ca_obj_tile.c +1 -0
data/ext/ca_obj_triop.c +9 -1
data/ext/ca_obj_window.c +1 -0
data/ext/ca_op_ipower.c +8 -8
data/ext/caframe_csv_reader.c +1 -1
data/ext/carray.h +2 -1
data/ext/carray_access.c +27 -64
data/ext/carray_address_basis.c +134 -0
data/ext/carray_attribute.c +8 -0
data/ext/carray_broadcast.c +3 -4
data/ext/carray_build_flags.h +1 -1
data/ext/carray_cast.c +8 -11
data/ext/carray_conversion.c +9 -5
data/ext/carray_core.c +811 -72
data/ext/carray_element.c +13 -9
data/ext/carray_histogram.c +25 -3
data/ext/carray_internal.h +147 -12
data/ext/carray_kernels_bincmp.c +2007 -3
data/ext/carray_kernels_binop.c +25365 -5199
data/ext/carray_kernels_init.c +8 -8
data/ext/carray_kernels_monop.c +10696 -3678
data/ext/carray_kernels_reduce_aggregate.c +4429 -702
data/ext/carray_kernels_reduce_boolean.c +1533 -15
data/ext/carray_kernels_reduce_cumulative.c +1808 -248
data/ext/carray_kernels_reduce_extreme.c +4508 -511
data/ext/carray_kernels_reduce_variance.c +2284 -152
data/ext/carray_kernels_scan.c +240 -240
data/ext/carray_kernels_search.c +4211 -264
data/ext/carray_kernels_sort.c +367 -450
data/ext/carray_lazy.c +47 -0
data/ext/carray_loop.c +1 -1
data/ext/carray_mask.c +130 -139
data/ext/carray_median_percentile.c +4 -4
data/ext/carray_memory_view.c +13 -7
data/ext/carray_operator.c +147 -44
data/ext/carray_order.c +3 -2
data/ext/carray_random.c +4 -1
data/ext/carray_slab.c +97 -21
data/ext/carray_sort.c +1 -1
data/ext/carray_test.c +74 -19
data/ext/carray_time_text.c +2 -2
data/ext/extconf.rb +11 -0
data/ext/mkkernel.rb +346 -94
data/ext/ruby_carray.c +4 -1
data/ext/version.h +4 -4
data/lib/carray/attribute.rb +25 -1
data/lib/carray/autoload_carray.rb +3 -3
data/lib/carray/autoload_method_extension.rb +5 -3
data/lib/carray/axis_group.rb +13 -7
data/lib/carray/basics.rb +1 -1
data/lib/carray/block_iterator.rb +17 -3
data/lib/carray/categorical.rb +6 -8
data/lib/carray/categorical_iterator.rb +2 -2
data/lib/carray/complex.rb +2 -2
data/lib/carray/conditional.rb +3 -2
data/lib/carray/frame/column_verbs.rb +45 -14
data/lib/carray/frame/convert.rb +19 -0
data/lib/carray/frame/csv_parser.rb +32 -32
data/lib/carray/frame/describe.rb +4 -2
data/lib/carray/frame/frame.rb +399 -78
data/lib/carray/frame/group.rb +679 -53
data/lib/carray/frame/io.rb +209 -71
data/lib/carray/frame/join.rb +146 -37
data/lib/carray/frame/records.rb +3 -3
data/lib/carray/frame/reshape.rb +89 -11
data/lib/carray/frame/sort.rb +57 -9
data/lib/carray/frame/verbs.rb +384 -49
data/lib/carray/frame/windows.rb +44 -6
data/lib/carray/inspect.rb +7 -2
data/lib/carray/iterator.rb +32 -0
data/lib/carray/lazy.rb +17 -8
data/lib/carray/mask_gap_fill.rb +37 -17
data/lib/carray/meld_reduce.rb +1 -1
data/lib/carray/methods/choose.rb +3 -2
data/lib/carray/methods/meshgrid.rb +3 -1
data/lib/carray/runtime.rb +47 -8
data/lib/carray/segment_iterator.rb +23 -8
data/lib/carray/serialize.rb +34 -17
data/lib/carray/stack.rb +18 -6
data/lib/carray/time.rb +5 -0
data/lib/carray/window_iterator.rb +16 -4
data/yard-stubs/ca_obj_array.rb +26 -1
data/yard-stubs/carray_cast.rb +8 -5
data/yard-stubs/carray_conversion.rb +8 -2
data/yard-stubs/carray_mask.rb +20 -1
data/yard-stubs/carray_math.rb +31 -16
data/yard-stubs/carray_memory_view.rb +7 -0
data/yard-stubs/carray_test.rb +7 -4
metadata +18 -4

data/ext/carray_kernels_reduce_variance.c CHANGED Viewed

@@ -47,14 +47,40 @@ static inline VALUE BOOL2VAL (boolean8_t x) { return x ? Qtrue : Qfalse; }
 #define __variancep_i8_P1EXPR(__x) ((double)(__x))
 #define __variancep_i8_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variancep_ki_native_i8_frame;
 static VALUE
-variancep_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variancep_ki_native_i8_body (VALUE arg)
 {
+  variancep_ki_native_i8_frame *fr = (variancep_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])
   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 ) {
@@ -69,7 +95,7 @@ variancep_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     /* Pass 1: sum = Σx (+ masked_cnt) */
     double sum = 0.0;
     ca_size_t masked_cnt = 0;
-    CA_SLAB_REDUCE_SUM8_EX(int8_t, double, st, p, m, sum, 0.0, __variancep_i8_P1EXPR, masked_cnt);
+    CA_SLAB_REDUCE_SUM8_NARROW_EX(int8_t, double, st, p, m, sum, 0.0, __variancep_i8_P1EXPR, masked_cnt);
     ca_size_t n_valid = st.slab_elements - masked_cnt;
     int __trigger = ca_too_few_present(n_valid, min_count, 1);
     if ( __trigger ) {
@@ -84,7 +110,7 @@ variancep_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
       /* Pass 2: M2 = Σ (x - mean)² */
       double M2 = 0.0;
       ca_size_t __unused_mc = 0;
-      CA_SLAB_REDUCE_SUM8_EX(int8_t, double, st, p, m, M2, 0.0, __variancep_i8_P2EXPR, __unused_mc);
+      CA_SLAB_REDUCE_M2_NARROW_EX(int8_t, int32_t, st, p, m, M2, 0.0, mean, __variancep_i8_P2EXPR, __unused_mc);
       op[out_i++] = (ca_u_float64_t)(M2 / (double)(n_valid));
     }
   }
@@ -98,20 +124,61 @@ variancep_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
 }
+static VALUE
+variancep_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variancep_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, variancep_ki_native_i8_body, (VALUE) &fr);
+}
 #undef __variancep_i8_P1EXPR
 #undef __variancep_i8_P2EXPR
 #define __variancep_u8_P1EXPR(__x) ((double)(__x))
 #define __variancep_u8_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variancep_ki_native_u8_frame;
 static VALUE
-variancep_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variancep_ki_native_u8_body (VALUE arg)
 {
+  variancep_ki_native_u8_frame *fr = (variancep_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])
   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 ) {
@@ -126,7 +193,7 @@ variancep_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     /* Pass 1: sum = Σx (+ masked_cnt) */
     double sum = 0.0;
     ca_size_t masked_cnt = 0;
-    CA_SLAB_REDUCE_SUM8_EX(uint8_t, double, st, p, m, sum, 0.0, __variancep_u8_P1EXPR, masked_cnt);
+    CA_SLAB_REDUCE_SUM8_NARROW_EX(uint8_t, double, st, p, m, sum, 0.0, __variancep_u8_P1EXPR, masked_cnt);
     ca_size_t n_valid = st.slab_elements - masked_cnt;
     int __trigger = ca_too_few_present(n_valid, min_count, 1);
     if ( __trigger ) {
@@ -141,7 +208,7 @@ variancep_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
       /* Pass 2: M2 = Σ (x - mean)² */
       double M2 = 0.0;
       ca_size_t __unused_mc = 0;
-      CA_SLAB_REDUCE_SUM8_EX(uint8_t, double, st, p, m, M2, 0.0, __variancep_u8_P2EXPR, __unused_mc);
+      CA_SLAB_REDUCE_M2_NARROW_EX(uint8_t, int32_t, st, p, m, M2, 0.0, mean, __variancep_u8_P2EXPR, __unused_mc);
       op[out_i++] = (ca_u_float64_t)(M2 / (double)(n_valid));
     }
   }
@@ -155,20 +222,61 @@ variancep_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variancep_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variancep_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, variancep_ki_native_u8_body, (VALUE) &fr);
 }
 #undef __variancep_u8_P1EXPR
 #undef __variancep_u8_P2EXPR
 #define __variancep_i16_P1EXPR(__x) ((double)(__x))
 #define __variancep_i16_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variancep_ki_native_i16_frame;
 static VALUE
-variancep_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variancep_ki_native_i16_body (VALUE arg)
 {
+  variancep_ki_native_i16_frame *fr = (variancep_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])
   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 ) {
@@ -183,7 +291,7 @@ variancep_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
     /* Pass 1: sum = Σx (+ masked_cnt) */
     double sum = 0.0;
     ca_size_t masked_cnt = 0;
-    CA_SLAB_REDUCE_SUM8_EX(ca_u_int16_t, double, st, p, m, sum, 0.0, __variancep_i16_P1EXPR, masked_cnt);
+    CA_SLAB_REDUCE_SUM8_NARROW_EX(ca_u_int16_t, double, st, p, m, sum, 0.0, __variancep_i16_P1EXPR, masked_cnt);
     ca_size_t n_valid = st.slab_elements - masked_cnt;
     int __trigger = ca_too_few_present(n_valid, min_count, 1);
     if ( __trigger ) {
@@ -198,7 +306,7 @@ variancep_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
       /* Pass 2: M2 = Σ (x - mean)² */
       double M2 = 0.0;
       ca_size_t __unused_mc = 0;
-      CA_SLAB_REDUCE_SUM8_EX(ca_u_int16_t, double, st, p, m, M2, 0.0, __variancep_i16_P2EXPR, __unused_mc);
+      CA_SLAB_REDUCE_M2_NARROW_EX(ca_u_int16_t, int64_t, st, p, m, M2, 0.0, mean, __variancep_i16_P2EXPR, __unused_mc);
       op[out_i++] = (ca_u_float64_t)(M2 / (double)(n_valid));
     }
   }
@@ -212,20 +320,61 @@ variancep_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variancep_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variancep_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, variancep_ki_native_i16_body, (VALUE) &fr);
 }
 #undef __variancep_i16_P1EXPR
 #undef __variancep_i16_P2EXPR
 #define __variancep_u16_P1EXPR(__x) ((double)(__x))
 #define __variancep_u16_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variancep_ki_native_u16_frame;
 static VALUE
-variancep_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variancep_ki_native_u16_body (VALUE arg)
 {
+  variancep_ki_native_u16_frame *fr = (variancep_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])
   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 ) {
@@ -240,7 +389,7 @@ variancep_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
     /* Pass 1: sum = Σx (+ masked_cnt) */
     double sum = 0.0;
     ca_size_t masked_cnt = 0;
-    CA_SLAB_REDUCE_SUM8_EX(ca_u_uint16_t, double, st, p, m, sum, 0.0, __variancep_u16_P1EXPR, masked_cnt);
+    CA_SLAB_REDUCE_SUM8_NARROW_EX(ca_u_uint16_t, double, st, p, m, sum, 0.0, __variancep_u16_P1EXPR, masked_cnt);
     ca_size_t n_valid = st.slab_elements - masked_cnt;
     int __trigger = ca_too_few_present(n_valid, min_count, 1);
     if ( __trigger ) {
@@ -255,7 +404,7 @@ variancep_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
       /* Pass 2: M2 = Σ (x - mean)² */
       double M2 = 0.0;
       ca_size_t __unused_mc = 0;
-      CA_SLAB_REDUCE_SUM8_EX(ca_u_uint16_t, double, st, p, m, M2, 0.0, __variancep_u16_P2EXPR, __unused_mc);
+      CA_SLAB_REDUCE_M2_NARROW_EX(ca_u_uint16_t, int64_t, st, p, m, M2, 0.0, mean, __variancep_u16_P2EXPR, __unused_mc);
       op[out_i++] = (ca_u_float64_t)(M2 / (double)(n_valid));
     }
   }
@@ -269,20 +418,61 @@ variancep_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
 }
+static VALUE
+variancep_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variancep_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, variancep_ki_native_u16_body, (VALUE) &fr);
+}
 #undef __variancep_u16_P1EXPR
 #undef __variancep_u16_P2EXPR
 #define __variancep_i32_P1EXPR(__x) ((double)(__x))
 #define __variancep_i32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variancep_ki_native_i32_frame;
 static VALUE
-variancep_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variancep_ki_native_i32_body (VALUE arg)
 {
+  variancep_ki_native_i32_frame *fr = (variancep_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])
   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 ) {
@@ -326,20 +516,61 @@ variancep_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
 }
+static VALUE
+variancep_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variancep_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, variancep_ki_native_i32_body, (VALUE) &fr);
+}
 #undef __variancep_i32_P1EXPR
 #undef __variancep_i32_P2EXPR
 #define __variancep_u32_P1EXPR(__x) ((double)(__x))
 #define __variancep_u32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variancep_ki_native_u32_frame;
 static VALUE
-variancep_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variancep_ki_native_u32_body (VALUE arg)
 {
+  variancep_ki_native_u32_frame *fr = (variancep_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])
   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 ) {
@@ -383,20 +614,61 @@ variancep_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variancep_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variancep_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, variancep_ki_native_u32_body, (VALUE) &fr);
 }
 #undef __variancep_u32_P1EXPR
 #undef __variancep_u32_P2EXPR
 #define __variancep_i64_P1EXPR(__x) ((double)(__x))
 #define __variancep_i64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variancep_ki_native_i64_frame;
 static VALUE
-variancep_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variancep_ki_native_i64_body (VALUE arg)
 {
+  variancep_ki_native_i64_frame *fr = (variancep_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])
   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 ) {
@@ -440,20 +712,61 @@ variancep_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
 }
+static VALUE
+variancep_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variancep_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, variancep_ki_native_i64_body, (VALUE) &fr);
+}
 #undef __variancep_i64_P1EXPR
 #undef __variancep_i64_P2EXPR
 #define __variancep_u64_P1EXPR(__x) ((double)(__x))
 #define __variancep_u64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variancep_ki_native_u64_frame;
 static VALUE
-variancep_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variancep_ki_native_u64_body (VALUE arg)
 {
+  variancep_ki_native_u64_frame *fr = (variancep_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])
   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 ) {
@@ -497,20 +810,61 @@ variancep_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
 }
+static VALUE
+variancep_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variancep_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, variancep_ki_native_u64_body, (VALUE) &fr);
+}
 #undef __variancep_u64_P1EXPR
 #undef __variancep_u64_P2EXPR
 #define __variancep_f32_P1EXPR(__x) ((double)(__x))
 #define __variancep_f32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variancep_ki_native_f32_frame;
 static VALUE
-variancep_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variancep_ki_native_f32_body (VALUE arg)
 {
+  variancep_ki_native_f32_frame *fr = (variancep_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])
   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 ) {
@@ -554,20 +908,61 @@ variancep_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variancep_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variancep_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, variancep_ki_native_f32_body, (VALUE) &fr);
 }
 #undef __variancep_f32_P1EXPR
 #undef __variancep_f32_P2EXPR
 #define __variancep_f64_P1EXPR(__x) ((double)(__x))
 #define __variancep_f64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variancep_ki_native_f64_frame;
 static VALUE
-variancep_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variancep_ki_native_f64_body (VALUE arg)
 {
+  variancep_ki_native_f64_frame *fr = (variancep_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])
   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 ) {
@@ -611,20 +1006,61 @@ variancep_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variancep_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variancep_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, variancep_ki_native_f64_body, (VALUE) &fr);
 }
 #undef __variancep_f64_P1EXPR
 #undef __variancep_f64_P2EXPR
 #define __variancep_cmplx64_P1EXPR(__x) (__x)
 #define __variancep_cmplx64_P2EXPR(__x) (creal((__x) - mean) * creal((__x) - mean) + cimag((__x) - mean) * cimag((__x) - mean))
+/* 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;
+} variancep_ki_native_cmplx64_frame;
 static VALUE
-variancep_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variancep_ki_native_cmplx64_body (VALUE arg)
 {
+  variancep_ki_native_cmplx64_frame *fr = (variancep_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])
   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 ) {
@@ -668,20 +1104,61 @@ variancep_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t n
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
 }
+static VALUE
+variancep_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variancep_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, variancep_ki_native_cmplx64_body, (VALUE) &fr);
+}
 #undef __variancep_cmplx64_P1EXPR
 #undef __variancep_cmplx64_P2EXPR
 #define __variancep_cmplx128_P1EXPR(__x) (__x)
 #define __variancep_cmplx128_P2EXPR(__x) (creal((__x) - mean) * creal((__x) - mean) + cimag((__x) - mean) * cimag((__x) - mean))
+/* 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;
+} variancep_ki_native_cmplx128_frame;
 static VALUE
-variancep_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variancep_ki_native_cmplx128_body (VALUE arg)
 {
+  variancep_ki_native_cmplx128_frame *fr = (variancep_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])
   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 ) {
@@ -725,20 +1202,61 @@ variancep_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variancep_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variancep_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, variancep_ki_native_cmplx128_body, (VALUE) &fr);
 }
 #undef __variancep_cmplx128_P1EXPR
 #undef __variancep_cmplx128_P2EXPR
 #define __variancep_bool_P1EXPR(__x) ((double)(__x))
 #define __variancep_bool_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variancep_ki_native_bool_frame;
 static VALUE
-variancep_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variancep_ki_native_bool_body (VALUE arg)
 {
+  variancep_ki_native_bool_frame *fr = (variancep_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])
   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 ) {
@@ -782,13 +1300,28 @@ variancep_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variancep_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variancep_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, variancep_ki_native_bool_body, (VALUE) &fr);
 }
 #undef __variancep_bool_P1EXPR
 #undef __variancep_bool_P2EXPR
-/* 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;
@@ -877,7 +1410,7 @@ variancep_ki_native_object (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
   fr.naxes = naxes;
   fr.keep_axis = keep_axis;
   fr.min_count = min_count;
-  return ca_iter_ensure(1, fr.states, variancep_ki_native_object_body, (VALUE) &fr);
+  return ca_iter_ensure_computing(ca, 1, fr.states, variancep_ki_native_object_body, (VALUE) &fr);
 }
@@ -995,14 +1528,40 @@ rb_ca_variancep_ki (int argc, VALUE *argv, VALUE self)
 #define __variance_i8_P1EXPR(__x) ((double)(__x))
 #define __variance_i8_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variance_ki_native_i8_frame;
 static VALUE
-variance_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variance_ki_native_i8_body (VALUE arg)
 {
+  variance_ki_native_i8_frame *fr = (variance_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])
   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 ) {
@@ -1017,7 +1576,7 @@ variance_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     /* Pass 1: sum = Σx (+ masked_cnt) */
     double sum = 0.0;
     ca_size_t masked_cnt = 0;
-    CA_SLAB_REDUCE_SUM8_EX(int8_t, double, st, p, m, sum, 0.0, __variance_i8_P1EXPR, masked_cnt);
+    CA_SLAB_REDUCE_SUM8_NARROW_EX(int8_t, double, st, p, m, sum, 0.0, __variance_i8_P1EXPR, masked_cnt);
     ca_size_t n_valid = st.slab_elements - masked_cnt;
     int __trigger = ca_too_few_present(n_valid, min_count, 2);
     if ( __trigger ) {
@@ -1032,7 +1591,7 @@ variance_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
       /* Pass 2: M2 = Σ (x - mean)² */
       double M2 = 0.0;
       ca_size_t __unused_mc = 0;
-      CA_SLAB_REDUCE_SUM8_EX(int8_t, double, st, p, m, M2, 0.0, __variance_i8_P2EXPR, __unused_mc);
+      CA_SLAB_REDUCE_M2_NARROW_EX(int8_t, int32_t, st, p, m, M2, 0.0, mean, __variance_i8_P2EXPR, __unused_mc);
       op[out_i++] = (ca_u_float64_t)(M2 / (double)(n_valid - 1));
     }
   }
@@ -1046,20 +1605,61 @@ variance_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variance_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variance_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, variance_ki_native_i8_body, (VALUE) &fr);
 }
 #undef __variance_i8_P1EXPR
 #undef __variance_i8_P2EXPR
 #define __variance_u8_P1EXPR(__x) ((double)(__x))
 #define __variance_u8_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variance_ki_native_u8_frame;
 static VALUE
-variance_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variance_ki_native_u8_body (VALUE arg)
 {
+  variance_ki_native_u8_frame *fr = (variance_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])
   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 ) {
@@ -1074,7 +1674,7 @@ variance_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     /* Pass 1: sum = Σx (+ masked_cnt) */
     double sum = 0.0;
     ca_size_t masked_cnt = 0;
-    CA_SLAB_REDUCE_SUM8_EX(uint8_t, double, st, p, m, sum, 0.0, __variance_u8_P1EXPR, masked_cnt);
+    CA_SLAB_REDUCE_SUM8_NARROW_EX(uint8_t, double, st, p, m, sum, 0.0, __variance_u8_P1EXPR, masked_cnt);
     ca_size_t n_valid = st.slab_elements - masked_cnt;
     int __trigger = ca_too_few_present(n_valid, min_count, 2);
     if ( __trigger ) {
@@ -1089,7 +1689,7 @@ variance_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
       /* Pass 2: M2 = Σ (x - mean)² */
       double M2 = 0.0;
       ca_size_t __unused_mc = 0;
-      CA_SLAB_REDUCE_SUM8_EX(uint8_t, double, st, p, m, M2, 0.0, __variance_u8_P2EXPR, __unused_mc);
+      CA_SLAB_REDUCE_M2_NARROW_EX(uint8_t, int32_t, st, p, m, M2, 0.0, mean, __variance_u8_P2EXPR, __unused_mc);
       op[out_i++] = (ca_u_float64_t)(M2 / (double)(n_valid - 1));
     }
   }
@@ -1103,20 +1703,61 @@ variance_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
 }
+static VALUE
+variance_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variance_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, variance_ki_native_u8_body, (VALUE) &fr);
+}
 #undef __variance_u8_P1EXPR
 #undef __variance_u8_P2EXPR
 #define __variance_i16_P1EXPR(__x) ((double)(__x))
 #define __variance_i16_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variance_ki_native_i16_frame;
 static VALUE
-variance_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variance_ki_native_i16_body (VALUE arg)
 {
+  variance_ki_native_i16_frame *fr = (variance_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])
   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 ) {
@@ -1131,7 +1772,7 @@ variance_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     /* Pass 1: sum = Σx (+ masked_cnt) */
     double sum = 0.0;
     ca_size_t masked_cnt = 0;
-    CA_SLAB_REDUCE_SUM8_EX(ca_u_int16_t, double, st, p, m, sum, 0.0, __variance_i16_P1EXPR, masked_cnt);
+    CA_SLAB_REDUCE_SUM8_NARROW_EX(ca_u_int16_t, double, st, p, m, sum, 0.0, __variance_i16_P1EXPR, masked_cnt);
     ca_size_t n_valid = st.slab_elements - masked_cnt;
     int __trigger = ca_too_few_present(n_valid, min_count, 2);
     if ( __trigger ) {
@@ -1146,7 +1787,7 @@ variance_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
       /* Pass 2: M2 = Σ (x - mean)² */
       double M2 = 0.0;
       ca_size_t __unused_mc = 0;
-      CA_SLAB_REDUCE_SUM8_EX(ca_u_int16_t, double, st, p, m, M2, 0.0, __variance_i16_P2EXPR, __unused_mc);
+      CA_SLAB_REDUCE_M2_NARROW_EX(ca_u_int16_t, int64_t, st, p, m, M2, 0.0, mean, __variance_i16_P2EXPR, __unused_mc);
       op[out_i++] = (ca_u_float64_t)(M2 / (double)(n_valid - 1));
     }
   }
@@ -1160,20 +1801,61 @@ variance_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variance_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variance_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, variance_ki_native_i16_body, (VALUE) &fr);
 }
 #undef __variance_i16_P1EXPR
 #undef __variance_i16_P2EXPR
 #define __variance_u16_P1EXPR(__x) ((double)(__x))
 #define __variance_u16_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variance_ki_native_u16_frame;
 static VALUE
-variance_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variance_ki_native_u16_body (VALUE arg)
 {
+  variance_ki_native_u16_frame *fr = (variance_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])
   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 ) {
@@ -1188,7 +1870,7 @@ variance_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     /* Pass 1: sum = Σx (+ masked_cnt) */
     double sum = 0.0;
     ca_size_t masked_cnt = 0;
-    CA_SLAB_REDUCE_SUM8_EX(ca_u_uint16_t, double, st, p, m, sum, 0.0, __variance_u16_P1EXPR, masked_cnt);
+    CA_SLAB_REDUCE_SUM8_NARROW_EX(ca_u_uint16_t, double, st, p, m, sum, 0.0, __variance_u16_P1EXPR, masked_cnt);
     ca_size_t n_valid = st.slab_elements - masked_cnt;
     int __trigger = ca_too_few_present(n_valid, min_count, 2);
     if ( __trigger ) {
@@ -1203,7 +1885,7 @@ variance_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
       /* Pass 2: M2 = Σ (x - mean)² */
       double M2 = 0.0;
       ca_size_t __unused_mc = 0;
-      CA_SLAB_REDUCE_SUM8_EX(ca_u_uint16_t, double, st, p, m, M2, 0.0, __variance_u16_P2EXPR, __unused_mc);
+      CA_SLAB_REDUCE_M2_NARROW_EX(ca_u_uint16_t, int64_t, st, p, m, M2, 0.0, mean, __variance_u16_P2EXPR, __unused_mc);
       op[out_i++] = (ca_u_float64_t)(M2 / (double)(n_valid - 1));
     }
   }
@@ -1217,20 +1899,61 @@ variance_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variance_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variance_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, variance_ki_native_u16_body, (VALUE) &fr);
 }
 #undef __variance_u16_P1EXPR
 #undef __variance_u16_P2EXPR
 #define __variance_i32_P1EXPR(__x) ((double)(__x))
 #define __variance_i32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variance_ki_native_i32_frame;
 static VALUE
-variance_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variance_ki_native_i32_body (VALUE arg)
 {
+  variance_ki_native_i32_frame *fr = (variance_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])
   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 ) {
@@ -1274,20 +1997,61 @@ variance_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variance_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variance_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, variance_ki_native_i32_body, (VALUE) &fr);
 }
 #undef __variance_i32_P1EXPR
 #undef __variance_i32_P2EXPR
 #define __variance_u32_P1EXPR(__x) ((double)(__x))
 #define __variance_u32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variance_ki_native_u32_frame;
 static VALUE
-variance_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variance_ki_native_u32_body (VALUE arg)
 {
+  variance_ki_native_u32_frame *fr = (variance_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])
   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 ) {
@@ -1331,20 +2095,61 @@ variance_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
 }
+static VALUE
+variance_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variance_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, variance_ki_native_u32_body, (VALUE) &fr);
+}
 #undef __variance_u32_P1EXPR
 #undef __variance_u32_P2EXPR
 #define __variance_i64_P1EXPR(__x) ((double)(__x))
 #define __variance_i64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variance_ki_native_i64_frame;
 static VALUE
-variance_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variance_ki_native_i64_body (VALUE arg)
 {
+  variance_ki_native_i64_frame *fr = (variance_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])
   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 ) {
@@ -1388,20 +2193,61 @@ variance_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variance_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variance_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, variance_ki_native_i64_body, (VALUE) &fr);
 }
 #undef __variance_i64_P1EXPR
 #undef __variance_i64_P2EXPR
 #define __variance_u64_P1EXPR(__x) ((double)(__x))
 #define __variance_u64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variance_ki_native_u64_frame;
 static VALUE
-variance_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variance_ki_native_u64_body (VALUE arg)
 {
+  variance_ki_native_u64_frame *fr = (variance_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])
   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 ) {
@@ -1445,20 +2291,61 @@ variance_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variance_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variance_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, variance_ki_native_u64_body, (VALUE) &fr);
 }
 #undef __variance_u64_P1EXPR
 #undef __variance_u64_P2EXPR
 #define __variance_f32_P1EXPR(__x) ((double)(__x))
 #define __variance_f32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variance_ki_native_f32_frame;
 static VALUE
-variance_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variance_ki_native_f32_body (VALUE arg)
 {
+  variance_ki_native_f32_frame *fr = (variance_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])
   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 ) {
@@ -1502,20 +2389,61 @@ variance_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variance_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variance_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, variance_ki_native_f32_body, (VALUE) &fr);
 }
 #undef __variance_f32_P1EXPR
 #undef __variance_f32_P2EXPR
 #define __variance_f64_P1EXPR(__x) ((double)(__x))
 #define __variance_f64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variance_ki_native_f64_frame;
 static VALUE
-variance_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variance_ki_native_f64_body (VALUE arg)
 {
+  variance_ki_native_f64_frame *fr = (variance_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])
   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 ) {
@@ -1559,20 +2487,61 @@ variance_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
 }
+static VALUE
+variance_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variance_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, variance_ki_native_f64_body, (VALUE) &fr);
+}
 #undef __variance_f64_P1EXPR
 #undef __variance_f64_P2EXPR
 #define __variance_cmplx64_P1EXPR(__x) (__x)
 #define __variance_cmplx64_P2EXPR(__x) (creal((__x) - mean) * creal((__x) - mean) + cimag((__x) - mean) * cimag((__x) - mean))
+/* 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;
+} variance_ki_native_cmplx64_frame;
 static VALUE
-variance_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variance_ki_native_cmplx64_body (VALUE arg)
 {
+  variance_ki_native_cmplx64_frame *fr = (variance_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])
   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 ) {
@@ -1616,20 +2585,61 @@ variance_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variance_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variance_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, variance_ki_native_cmplx64_body, (VALUE) &fr);
 }
 #undef __variance_cmplx64_P1EXPR
 #undef __variance_cmplx64_P2EXPR
 #define __variance_cmplx128_P1EXPR(__x) (__x)
 #define __variance_cmplx128_P2EXPR(__x) (creal((__x) - mean) * creal((__x) - mean) + cimag((__x) - mean) * cimag((__x) - mean))
+/* 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;
+} variance_ki_native_cmplx128_frame;
 static VALUE
-variance_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variance_ki_native_cmplx128_body (VALUE arg)
 {
+  variance_ki_native_cmplx128_frame *fr = (variance_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])
   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 ) {
@@ -1673,20 +2683,61 @@ variance_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t n
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variance_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variance_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, variance_ki_native_cmplx128_body, (VALUE) &fr);
 }
 #undef __variance_cmplx128_P1EXPR
 #undef __variance_cmplx128_P2EXPR
 #define __variance_bool_P1EXPR(__x) ((double)(__x))
 #define __variance_bool_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} variance_ki_native_bool_frame;
 static VALUE
-variance_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+variance_ki_native_bool_body (VALUE arg)
 {
+  variance_ki_native_bool_frame *fr = (variance_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])
   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 ) {
@@ -1730,13 +2781,28 @@ variance_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+variance_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variance_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, variance_ki_native_bool_body, (VALUE) &fr);
 }
 #undef __variance_bool_P1EXPR
 #undef __variance_bool_P2EXPR
-/* 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;
@@ -1825,7 +2891,7 @@ variance_ki_native_object (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
   fr.naxes = naxes;
   fr.keep_axis = keep_axis;
   fr.min_count = min_count;
-  return ca_iter_ensure(1, fr.states, variance_ki_native_object_body, (VALUE) &fr);
+  return ca_iter_ensure_computing(ca, 1, fr.states, variance_ki_native_object_body, (VALUE) &fr);
 }
@@ -1943,14 +3009,40 @@ rb_ca_variance_ki (int argc, VALUE *argv, VALUE self)
 #define __stddevp_i8_P1EXPR(__x) ((double)(__x))
 #define __stddevp_i8_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddevp_ki_native_i8_frame;
 static VALUE
-stddevp_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddevp_ki_native_i8_body (VALUE arg)
 {
+  stddevp_ki_native_i8_frame *fr = (stddevp_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])
   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 ) {
@@ -1965,7 +3057,7 @@ stddevp_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
     /* Pass 1: sum = Σx (+ masked_cnt) */
     double sum = 0.0;
     ca_size_t masked_cnt = 0;
-    CA_SLAB_REDUCE_SUM8_EX(int8_t, double, st, p, m, sum, 0.0, __stddevp_i8_P1EXPR, masked_cnt);
+    CA_SLAB_REDUCE_SUM8_NARROW_EX(int8_t, double, st, p, m, sum, 0.0, __stddevp_i8_P1EXPR, masked_cnt);
     ca_size_t n_valid = st.slab_elements - masked_cnt;
     int __trigger = ca_too_few_present(n_valid, min_count, 1);
     if ( __trigger ) {
@@ -1980,7 +3072,7 @@ stddevp_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
       /* Pass 2: M2 = Σ (x - mean)² */
       double M2 = 0.0;
       ca_size_t __unused_mc = 0;
-      CA_SLAB_REDUCE_SUM8_EX(int8_t, double, st, p, m, M2, 0.0, __stddevp_i8_P2EXPR, __unused_mc);
+      CA_SLAB_REDUCE_M2_NARROW_EX(int8_t, int32_t, st, p, m, M2, 0.0, mean, __stddevp_i8_P2EXPR, __unused_mc);
       op[out_i++] = (ca_u_float64_t)(ca_sqrt_clamp(M2 / (double)(n_valid)));
     }
   }
@@ -1994,20 +3086,61 @@ stddevp_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
 }
+static VALUE
+stddevp_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddevp_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, stddevp_ki_native_i8_body, (VALUE) &fr);
+}
 #undef __stddevp_i8_P1EXPR
 #undef __stddevp_i8_P2EXPR
 #define __stddevp_u8_P1EXPR(__x) ((double)(__x))
 #define __stddevp_u8_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddevp_ki_native_u8_frame;
 static VALUE
-stddevp_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddevp_ki_native_u8_body (VALUE arg)
 {
+  stddevp_ki_native_u8_frame *fr = (stddevp_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])
   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 ) {
@@ -2022,7 +3155,7 @@ stddevp_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
     /* Pass 1: sum = Σx (+ masked_cnt) */
     double sum = 0.0;
     ca_size_t masked_cnt = 0;
-    CA_SLAB_REDUCE_SUM8_EX(uint8_t, double, st, p, m, sum, 0.0, __stddevp_u8_P1EXPR, masked_cnt);
+    CA_SLAB_REDUCE_SUM8_NARROW_EX(uint8_t, double, st, p, m, sum, 0.0, __stddevp_u8_P1EXPR, masked_cnt);
     ca_size_t n_valid = st.slab_elements - masked_cnt;
     int __trigger = ca_too_few_present(n_valid, min_count, 1);
     if ( __trigger ) {
@@ -2037,7 +3170,7 @@ stddevp_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
       /* Pass 2: M2 = Σ (x - mean)² */
       double M2 = 0.0;
       ca_size_t __unused_mc = 0;
-      CA_SLAB_REDUCE_SUM8_EX(uint8_t, double, st, p, m, M2, 0.0, __stddevp_u8_P2EXPR, __unused_mc);
+      CA_SLAB_REDUCE_M2_NARROW_EX(uint8_t, int32_t, st, p, m, M2, 0.0, mean, __stddevp_u8_P2EXPR, __unused_mc);
       op[out_i++] = (ca_u_float64_t)(ca_sqrt_clamp(M2 / (double)(n_valid)));
     }
   }
@@ -2051,20 +3184,61 @@ stddevp_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddevp_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddevp_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, stddevp_ki_native_u8_body, (VALUE) &fr);
 }
 #undef __stddevp_u8_P1EXPR
 #undef __stddevp_u8_P2EXPR
 #define __stddevp_i16_P1EXPR(__x) ((double)(__x))
 #define __stddevp_i16_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddevp_ki_native_i16_frame;
 static VALUE
-stddevp_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddevp_ki_native_i16_body (VALUE arg)
 {
+  stddevp_ki_native_i16_frame *fr = (stddevp_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])
   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 ) {
@@ -2079,7 +3253,7 @@ stddevp_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     /* Pass 1: sum = Σx (+ masked_cnt) */
     double sum = 0.0;
     ca_size_t masked_cnt = 0;
-    CA_SLAB_REDUCE_SUM8_EX(ca_u_int16_t, double, st, p, m, sum, 0.0, __stddevp_i16_P1EXPR, masked_cnt);
+    CA_SLAB_REDUCE_SUM8_NARROW_EX(ca_u_int16_t, double, st, p, m, sum, 0.0, __stddevp_i16_P1EXPR, masked_cnt);
     ca_size_t n_valid = st.slab_elements - masked_cnt;
     int __trigger = ca_too_few_present(n_valid, min_count, 1);
     if ( __trigger ) {
@@ -2094,7 +3268,7 @@ stddevp_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
       /* Pass 2: M2 = Σ (x - mean)² */
       double M2 = 0.0;
       ca_size_t __unused_mc = 0;
-      CA_SLAB_REDUCE_SUM8_EX(ca_u_int16_t, double, st, p, m, M2, 0.0, __stddevp_i16_P2EXPR, __unused_mc);
+      CA_SLAB_REDUCE_M2_NARROW_EX(ca_u_int16_t, int64_t, st, p, m, M2, 0.0, mean, __stddevp_i16_P2EXPR, __unused_mc);
       op[out_i++] = (ca_u_float64_t)(ca_sqrt_clamp(M2 / (double)(n_valid)));
     }
   }
@@ -2108,20 +3282,61 @@ stddevp_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddevp_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddevp_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, stddevp_ki_native_i16_body, (VALUE) &fr);
 }
 #undef __stddevp_i16_P1EXPR
 #undef __stddevp_i16_P2EXPR
 #define __stddevp_u16_P1EXPR(__x) ((double)(__x))
 #define __stddevp_u16_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddevp_ki_native_u16_frame;
 static VALUE
-stddevp_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddevp_ki_native_u16_body (VALUE arg)
 {
+  stddevp_ki_native_u16_frame *fr = (stddevp_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])
   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 ) {
@@ -2136,7 +3351,7 @@ stddevp_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     /* Pass 1: sum = Σx (+ masked_cnt) */
     double sum = 0.0;
     ca_size_t masked_cnt = 0;
-    CA_SLAB_REDUCE_SUM8_EX(ca_u_uint16_t, double, st, p, m, sum, 0.0, __stddevp_u16_P1EXPR, masked_cnt);
+    CA_SLAB_REDUCE_SUM8_NARROW_EX(ca_u_uint16_t, double, st, p, m, sum, 0.0, __stddevp_u16_P1EXPR, masked_cnt);
     ca_size_t n_valid = st.slab_elements - masked_cnt;
     int __trigger = ca_too_few_present(n_valid, min_count, 1);
     if ( __trigger ) {
@@ -2151,7 +3366,7 @@ stddevp_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
       /* Pass 2: M2 = Σ (x - mean)² */
       double M2 = 0.0;
       ca_size_t __unused_mc = 0;
-      CA_SLAB_REDUCE_SUM8_EX(ca_u_uint16_t, double, st, p, m, M2, 0.0, __stddevp_u16_P2EXPR, __unused_mc);
+      CA_SLAB_REDUCE_M2_NARROW_EX(ca_u_uint16_t, int64_t, st, p, m, M2, 0.0, mean, __stddevp_u16_P2EXPR, __unused_mc);
       op[out_i++] = (ca_u_float64_t)(ca_sqrt_clamp(M2 / (double)(n_valid)));
     }
   }
@@ -2165,20 +3380,61 @@ stddevp_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddevp_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddevp_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, stddevp_ki_native_u16_body, (VALUE) &fr);
 }
 #undef __stddevp_u16_P1EXPR
 #undef __stddevp_u16_P2EXPR
 #define __stddevp_i32_P1EXPR(__x) ((double)(__x))
 #define __stddevp_i32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddevp_ki_native_i32_frame;
 static VALUE
-stddevp_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddevp_ki_native_i32_body (VALUE arg)
 {
+  stddevp_ki_native_i32_frame *fr = (stddevp_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])
   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 ) {
@@ -2222,20 +3478,61 @@ stddevp_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
 }
+static VALUE
+stddevp_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddevp_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, stddevp_ki_native_i32_body, (VALUE) &fr);
+}
 #undef __stddevp_i32_P1EXPR
 #undef __stddevp_i32_P2EXPR
 #define __stddevp_u32_P1EXPR(__x) ((double)(__x))
 #define __stddevp_u32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddevp_ki_native_u32_frame;
 static VALUE
-stddevp_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddevp_ki_native_u32_body (VALUE arg)
 {
+  stddevp_ki_native_u32_frame *fr = (stddevp_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])
   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 ) {
@@ -2279,20 +3576,61 @@ stddevp_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddevp_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddevp_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, stddevp_ki_native_u32_body, (VALUE) &fr);
 }
 #undef __stddevp_u32_P1EXPR
 #undef __stddevp_u32_P2EXPR
 #define __stddevp_i64_P1EXPR(__x) ((double)(__x))
 #define __stddevp_i64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddevp_ki_native_i64_frame;
 static VALUE
-stddevp_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddevp_ki_native_i64_body (VALUE arg)
 {
+  stddevp_ki_native_i64_frame *fr = (stddevp_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])
   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 ) {
@@ -2336,20 +3674,61 @@ stddevp_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddevp_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddevp_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, stddevp_ki_native_i64_body, (VALUE) &fr);
 }
 #undef __stddevp_i64_P1EXPR
 #undef __stddevp_i64_P2EXPR
 #define __stddevp_u64_P1EXPR(__x) ((double)(__x))
 #define __stddevp_u64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddevp_ki_native_u64_frame;
 static VALUE
-stddevp_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddevp_ki_native_u64_body (VALUE arg)
 {
+  stddevp_ki_native_u64_frame *fr = (stddevp_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])
   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 ) {
@@ -2393,20 +3772,61 @@ stddevp_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddevp_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddevp_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, stddevp_ki_native_u64_body, (VALUE) &fr);
 }
 #undef __stddevp_u64_P1EXPR
 #undef __stddevp_u64_P2EXPR
 #define __stddevp_f32_P1EXPR(__x) ((double)(__x))
 #define __stddevp_f32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddevp_ki_native_f32_frame;
 static VALUE
-stddevp_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddevp_ki_native_f32_body (VALUE arg)
 {
+  stddevp_ki_native_f32_frame *fr = (stddevp_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])
   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 ) {
@@ -2450,20 +3870,61 @@ stddevp_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
 }
+static VALUE
+stddevp_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddevp_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, stddevp_ki_native_f32_body, (VALUE) &fr);
+}
 #undef __stddevp_f32_P1EXPR
 #undef __stddevp_f32_P2EXPR
 #define __stddevp_f64_P1EXPR(__x) ((double)(__x))
 #define __stddevp_f64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddevp_ki_native_f64_frame;
 static VALUE
-stddevp_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddevp_ki_native_f64_body (VALUE arg)
 {
+  stddevp_ki_native_f64_frame *fr = (stddevp_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])
   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 ) {
@@ -2507,20 +3968,61 @@ stddevp_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddevp_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddevp_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, stddevp_ki_native_f64_body, (VALUE) &fr);
 }
 #undef __stddevp_f64_P1EXPR
 #undef __stddevp_f64_P2EXPR
 #define __stddevp_cmplx64_P1EXPR(__x) (__x)
 #define __stddevp_cmplx64_P2EXPR(__x) (creal((__x) - mean) * creal((__x) - mean) + cimag((__x) - mean) * cimag((__x) - mean))
+/* 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;
+} stddevp_ki_native_cmplx64_frame;
 static VALUE
-stddevp_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddevp_ki_native_cmplx64_body (VALUE arg)
 {
+  stddevp_ki_native_cmplx64_frame *fr = (stddevp_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])
   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 ) {
@@ -2564,20 +4066,61 @@ stddevp_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddevp_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddevp_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, stddevp_ki_native_cmplx64_body, (VALUE) &fr);
 }
 #undef __stddevp_cmplx64_P1EXPR
 #undef __stddevp_cmplx64_P2EXPR
 #define __stddevp_cmplx128_P1EXPR(__x) (__x)
 #define __stddevp_cmplx128_P2EXPR(__x) (creal((__x) - mean) * creal((__x) - mean) + cimag((__x) - mean) * cimag((__x) - mean))
+/* 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;
+} stddevp_ki_native_cmplx128_frame;
 static VALUE
-stddevp_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddevp_ki_native_cmplx128_body (VALUE arg)
 {
+  stddevp_ki_native_cmplx128_frame *fr = (stddevp_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])
   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 ) {
@@ -2621,20 +4164,61 @@ stddevp_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddevp_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddevp_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, stddevp_ki_native_cmplx128_body, (VALUE) &fr);
 }
 #undef __stddevp_cmplx128_P1EXPR
 #undef __stddevp_cmplx128_P2EXPR
 #define __stddevp_bool_P1EXPR(__x) ((double)(__x))
 #define __stddevp_bool_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddevp_ki_native_bool_frame;
 static VALUE
-stddevp_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddevp_ki_native_bool_body (VALUE arg)
 {
+  stddevp_ki_native_bool_frame *fr = (stddevp_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])
   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 ) {
@@ -2678,13 +4262,28 @@ stddevp_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
 }
+static VALUE
+stddevp_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddevp_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, stddevp_ki_native_bool_body, (VALUE) &fr);
+}
 #undef __stddevp_bool_P1EXPR
 #undef __stddevp_bool_P2EXPR
-/* 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;
@@ -2773,7 +4372,7 @@ stddevp_ki_native_object (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
   fr.naxes = naxes;
   fr.keep_axis = keep_axis;
   fr.min_count = min_count;
-  return ca_iter_ensure(1, fr.states, stddevp_ki_native_object_body, (VALUE) &fr);
+  return ca_iter_ensure_computing(ca, 1, fr.states, stddevp_ki_native_object_body, (VALUE) &fr);
 }
@@ -2891,14 +4490,40 @@ rb_ca_stddevp_ki (int argc, VALUE *argv, VALUE self)
 #define __stddev_i8_P1EXPR(__x) ((double)(__x))
 #define __stddev_i8_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddev_ki_native_i8_frame;
 static VALUE
-stddev_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddev_ki_native_i8_body (VALUE arg)
 {
+  stddev_ki_native_i8_frame *fr = (stddev_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])
   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 ) {
@@ -2913,7 +4538,7 @@ stddev_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, in
     /* Pass 1: sum = Σx (+ masked_cnt) */
     double sum = 0.0;
     ca_size_t masked_cnt = 0;
-    CA_SLAB_REDUCE_SUM8_EX(int8_t, double, st, p, m, sum, 0.0, __stddev_i8_P1EXPR, masked_cnt);
+    CA_SLAB_REDUCE_SUM8_NARROW_EX(int8_t, double, st, p, m, sum, 0.0, __stddev_i8_P1EXPR, masked_cnt);
     ca_size_t n_valid = st.slab_elements - masked_cnt;
     int __trigger = ca_too_few_present(n_valid, min_count, 2);
     if ( __trigger ) {
@@ -2928,7 +4553,7 @@ stddev_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, in
       /* Pass 2: M2 = Σ (x - mean)² */
       double M2 = 0.0;
       ca_size_t __unused_mc = 0;
-      CA_SLAB_REDUCE_SUM8_EX(int8_t, double, st, p, m, M2, 0.0, __stddev_i8_P2EXPR, __unused_mc);
+      CA_SLAB_REDUCE_M2_NARROW_EX(int8_t, int32_t, st, p, m, M2, 0.0, mean, __stddev_i8_P2EXPR, __unused_mc);
       op[out_i++] = (ca_u_float64_t)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
     }
   }
@@ -2942,20 +4567,61 @@ stddev_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, in
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddev_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddev_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, stddev_ki_native_i8_body, (VALUE) &fr);
 }
 #undef __stddev_i8_P1EXPR
 #undef __stddev_i8_P2EXPR
 #define __stddev_u8_P1EXPR(__x) ((double)(__x))
 #define __stddev_u8_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddev_ki_native_u8_frame;
 static VALUE
-stddev_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddev_ki_native_u8_body (VALUE arg)
 {
+  stddev_ki_native_u8_frame *fr = (stddev_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])
   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 ) {
@@ -2970,7 +4636,7 @@ stddev_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, in
     /* Pass 1: sum = Σx (+ masked_cnt) */
     double sum = 0.0;
     ca_size_t masked_cnt = 0;
-    CA_SLAB_REDUCE_SUM8_EX(uint8_t, double, st, p, m, sum, 0.0, __stddev_u8_P1EXPR, masked_cnt);
+    CA_SLAB_REDUCE_SUM8_NARROW_EX(uint8_t, double, st, p, m, sum, 0.0, __stddev_u8_P1EXPR, masked_cnt);
     ca_size_t n_valid = st.slab_elements - masked_cnt;
     int __trigger = ca_too_few_present(n_valid, min_count, 2);
     if ( __trigger ) {
@@ -2985,7 +4651,7 @@ stddev_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, in
       /* Pass 2: M2 = Σ (x - mean)² */
       double M2 = 0.0;
       ca_size_t __unused_mc = 0;
-      CA_SLAB_REDUCE_SUM8_EX(uint8_t, double, st, p, m, M2, 0.0, __stddev_u8_P2EXPR, __unused_mc);
+      CA_SLAB_REDUCE_M2_NARROW_EX(uint8_t, int32_t, st, p, m, M2, 0.0, mean, __stddev_u8_P2EXPR, __unused_mc);
       op[out_i++] = (ca_u_float64_t)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
     }
   }
@@ -2999,20 +4665,61 @@ stddev_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, in
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddev_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddev_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, stddev_ki_native_u8_body, (VALUE) &fr);
 }
 #undef __stddev_u8_P1EXPR
 #undef __stddev_u8_P2EXPR
 #define __stddev_i16_P1EXPR(__x) ((double)(__x))
 #define __stddev_i16_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddev_ki_native_i16_frame;
 static VALUE
-stddev_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddev_ki_native_i16_body (VALUE arg)
 {
+  stddev_ki_native_i16_frame *fr = (stddev_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])
   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 ) {
@@ -3027,7 +4734,7 @@ stddev_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
     /* Pass 1: sum = Σx (+ masked_cnt) */
     double sum = 0.0;
     ca_size_t masked_cnt = 0;
-    CA_SLAB_REDUCE_SUM8_EX(ca_u_int16_t, double, st, p, m, sum, 0.0, __stddev_i16_P1EXPR, masked_cnt);
+    CA_SLAB_REDUCE_SUM8_NARROW_EX(ca_u_int16_t, double, st, p, m, sum, 0.0, __stddev_i16_P1EXPR, masked_cnt);
     ca_size_t n_valid = st.slab_elements - masked_cnt;
     int __trigger = ca_too_few_present(n_valid, min_count, 2);
     if ( __trigger ) {
@@ -3042,7 +4749,7 @@ stddev_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
       /* Pass 2: M2 = Σ (x - mean)² */
       double M2 = 0.0;
       ca_size_t __unused_mc = 0;
-      CA_SLAB_REDUCE_SUM8_EX(ca_u_int16_t, double, st, p, m, M2, 0.0, __stddev_i16_P2EXPR, __unused_mc);
+      CA_SLAB_REDUCE_M2_NARROW_EX(ca_u_int16_t, int64_t, st, p, m, M2, 0.0, mean, __stddev_i16_P2EXPR, __unused_mc);
       op[out_i++] = (ca_u_float64_t)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
     }
   }
@@ -3056,20 +4763,61 @@ stddev_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddev_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddev_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, stddev_ki_native_i16_body, (VALUE) &fr);
 }
 #undef __stddev_i16_P1EXPR
 #undef __stddev_i16_P2EXPR
 #define __stddev_u16_P1EXPR(__x) ((double)(__x))
 #define __stddev_u16_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddev_ki_native_u16_frame;
 static VALUE
-stddev_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddev_ki_native_u16_body (VALUE arg)
 {
+  stddev_ki_native_u16_frame *fr = (stddev_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])
   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 ) {
@@ -3084,7 +4832,7 @@ stddev_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
     /* Pass 1: sum = Σx (+ masked_cnt) */
     double sum = 0.0;
     ca_size_t masked_cnt = 0;
-    CA_SLAB_REDUCE_SUM8_EX(ca_u_uint16_t, double, st, p, m, sum, 0.0, __stddev_u16_P1EXPR, masked_cnt);
+    CA_SLAB_REDUCE_SUM8_NARROW_EX(ca_u_uint16_t, double, st, p, m, sum, 0.0, __stddev_u16_P1EXPR, masked_cnt);
     ca_size_t n_valid = st.slab_elements - masked_cnt;
     int __trigger = ca_too_few_present(n_valid, min_count, 2);
     if ( __trigger ) {
@@ -3099,7 +4847,7 @@ stddev_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
       /* Pass 2: M2 = Σ (x - mean)² */
       double M2 = 0.0;
       ca_size_t __unused_mc = 0;
-      CA_SLAB_REDUCE_SUM8_EX(ca_u_uint16_t, double, st, p, m, M2, 0.0, __stddev_u16_P2EXPR, __unused_mc);
+      CA_SLAB_REDUCE_M2_NARROW_EX(ca_u_uint16_t, int64_t, st, p, m, M2, 0.0, mean, __stddev_u16_P2EXPR, __unused_mc);
       op[out_i++] = (ca_u_float64_t)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
     }
   }
@@ -3113,20 +4861,61 @@ stddev_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
 }
+static VALUE
+stddev_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddev_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, stddev_ki_native_u16_body, (VALUE) &fr);
+}
 #undef __stddev_u16_P1EXPR
 #undef __stddev_u16_P2EXPR
 #define __stddev_i32_P1EXPR(__x) ((double)(__x))
 #define __stddev_i32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddev_ki_native_i32_frame;
 static VALUE
-stddev_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddev_ki_native_i32_body (VALUE arg)
 {
+  stddev_ki_native_i32_frame *fr = (stddev_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])
   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 ) {
@@ -3170,20 +4959,61 @@ stddev_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddev_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddev_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, stddev_ki_native_i32_body, (VALUE) &fr);
 }
 #undef __stddev_i32_P1EXPR
 #undef __stddev_i32_P2EXPR
 #define __stddev_u32_P1EXPR(__x) ((double)(__x))
 #define __stddev_u32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddev_ki_native_u32_frame;
 static VALUE
-stddev_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddev_ki_native_u32_body (VALUE arg)
 {
+  stddev_ki_native_u32_frame *fr = (stddev_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])
   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 ) {
@@ -3227,20 +5057,61 @@ stddev_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddev_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddev_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, stddev_ki_native_u32_body, (VALUE) &fr);
 }
 #undef __stddev_u32_P1EXPR
 #undef __stddev_u32_P2EXPR
 #define __stddev_i64_P1EXPR(__x) ((double)(__x))
 #define __stddev_i64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddev_ki_native_i64_frame;
 static VALUE
-stddev_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddev_ki_native_i64_body (VALUE arg)
 {
+  stddev_ki_native_i64_frame *fr = (stddev_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])
   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 ) {
@@ -3284,20 +5155,61 @@ stddev_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddev_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddev_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, stddev_ki_native_i64_body, (VALUE) &fr);
 }
 #undef __stddev_i64_P1EXPR
 #undef __stddev_i64_P2EXPR
 #define __stddev_u64_P1EXPR(__x) ((double)(__x))
 #define __stddev_u64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddev_ki_native_u64_frame;
 static VALUE
-stddev_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddev_ki_native_u64_body (VALUE arg)
 {
+  stddev_ki_native_u64_frame *fr = (stddev_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])
   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 ) {
@@ -3341,20 +5253,61 @@ stddev_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
 }
+static VALUE
+stddev_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddev_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, stddev_ki_native_u64_body, (VALUE) &fr);
+}
 #undef __stddev_u64_P1EXPR
 #undef __stddev_u64_P2EXPR
 #define __stddev_f32_P1EXPR(__x) ((double)(__x))
 #define __stddev_f32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddev_ki_native_f32_frame;
 static VALUE
-stddev_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddev_ki_native_f32_body (VALUE arg)
 {
+  stddev_ki_native_f32_frame *fr = (stddev_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])
   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 ) {
@@ -3398,20 +5351,61 @@ stddev_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddev_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddev_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, stddev_ki_native_f32_body, (VALUE) &fr);
 }
 #undef __stddev_f32_P1EXPR
 #undef __stddev_f32_P2EXPR
 #define __stddev_f64_P1EXPR(__x) ((double)(__x))
 #define __stddev_f64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddev_ki_native_f64_frame;
 static VALUE
-stddev_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddev_ki_native_f64_body (VALUE arg)
 {
+  stddev_ki_native_f64_frame *fr = (stddev_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])
   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 ) {
@@ -3455,20 +5449,61 @@ stddev_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, i
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddev_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddev_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, stddev_ki_native_f64_body, (VALUE) &fr);
 }
 #undef __stddev_f64_P1EXPR
 #undef __stddev_f64_P2EXPR
 #define __stddev_cmplx64_P1EXPR(__x) (__x)
 #define __stddev_cmplx64_P2EXPR(__x) (creal((__x) - mean) * creal((__x) - mean) + cimag((__x) - mean) * cimag((__x) - mean))
+/* 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;
+} stddev_ki_native_cmplx64_frame;
 static VALUE
-stddev_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddev_ki_native_cmplx64_body (VALUE arg)
 {
+  stddev_ki_native_cmplx64_frame *fr = (stddev_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])
   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 ) {
@@ -3512,20 +5547,61 @@ stddev_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddev_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddev_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, stddev_ki_native_cmplx64_body, (VALUE) &fr);
 }
 #undef __stddev_cmplx64_P1EXPR
 #undef __stddev_cmplx64_P2EXPR
 #define __stddev_cmplx128_P1EXPR(__x) (__x)
 #define __stddev_cmplx128_P2EXPR(__x) (creal((__x) - mean) * creal((__x) - mean) + cimag((__x) - mean) * cimag((__x) - mean))
+/* 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;
+} stddev_ki_native_cmplx128_frame;
 static VALUE
-stddev_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddev_ki_native_cmplx128_body (VALUE arg)
 {
+  stddev_ki_native_cmplx128_frame *fr = (stddev_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])
   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 ) {
@@ -3569,20 +5645,61 @@ stddev_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
 }
+static VALUE
+stddev_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddev_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, stddev_ki_native_cmplx128_body, (VALUE) &fr);
+}
 #undef __stddev_cmplx128_P1EXPR
 #undef __stddev_cmplx128_P2EXPR
 #define __stddev_bool_P1EXPR(__x) ((double)(__x))
 #define __stddev_bool_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+/* 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;
+} stddev_ki_native_bool_frame;
 static VALUE
-stddev_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+stddev_ki_native_bool_body (VALUE arg)
 {
+  stddev_ki_native_bool_frame *fr = (stddev_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])
   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 ) {
@@ -3626,13 +5743,28 @@ stddev_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes,
     return rb_float_new(op[0]);
   }
   return vout;
+#undef st
+}
+static VALUE
+stddev_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddev_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, stddev_ki_native_bool_body, (VALUE) &fr);
 }
 #undef __stddev_bool_P1EXPR
 #undef __stddev_bool_P2EXPR
-/* 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;
@@ -3721,7 +5853,7 @@ stddev_ki_native_object (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes
   fr.naxes = naxes;
   fr.keep_axis = keep_axis;
   fr.min_count = min_count;
-  return ca_iter_ensure(1, fr.states, stddev_ki_native_object_body, (VALUE) &fr);
+  return ca_iter_ensure_computing(ca, 1, fr.states, stddev_ki_native_object_body, (VALUE) &fr);
 }