carray 3.0.3 → 3.0.4

data/ext/carray_kernels_scan.c

@@ -0,0 +1,4302 @@
+/* ---------------------------------------------------------------------------
+
+   carray_kernels.c -- GENERATED by ext/mkkernel.rb -- DO NOT EDIT
+
+   Kernel definitions live in mkkernel.rb (search for `MkKernel.reduce`).
+   Regenerate by running:
+
+     cd ext && ruby mkkernel.rb > carray_kernels.c
+
+   extconf.rb regenerates automatically when mkkernel.rb is touched.
+
+   --------------------------------------------------------------------------- */
+
+#include "carray.h"
+#include "ca_kernel_iterator.h"
+#include "ca_sort_kernels.h"   /* sort kernels: internal, not via the carray.h umbrella */
+#include "carray_internal.h"   /* ca_lazy_arena_*, ca_is_lazy_view (streaming reduce) */
+#include "ca_obj_face.h"       /* rb_ca_strip_face_value (Face ordering gate) */
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>   /* qsort, mergesort (HAVE_MERGESORT) -- for :sort kind */
+
+/* MEMO_REDUCTION_FASTPATH_ENTITY_ONLY_GUARD Tier 2: CAStack identity is
+   probed by operation-table function pointer (obj_type is runtime-
+   assigned, so no CA_OBJ_STACK compile-time constant exists). */
+extern ca_operation_function_t ca_stack_func;
+/* The square root of a variance: an ε-negative from rounding becomes 0,
+   a NaN stays NaN (fmax(NaN, 0.0) is 0.0). */
+#ifndef CARRAY_SQRT_CLAMP_DEFINED
+#define CARRAY_SQRT_CLAMP_DEFINED
+static inline double ca_sqrt_clamp (double v) { return sqrt(v < 0.0 ? 0.0 : v); }
+#endif
+
+/* BOOL2VAL: bool -> Ruby (Qtrue/Qfalse).  Used as ruby_scalar wrapper
+   for the all/any flat-reduction Ruby surface so `a.all` / `a.any`
+   return real true/false, not Integer 0/1.  (BOOL2OBJ already exists
+   but returns Integer per CArray's boolean-as-int convention.)  */
+#ifndef CARRAY_BOOL2VAL_DEFINED
+#define CARRAY_BOOL2VAL_DEFINED
+static inline VALUE BOOL2VAL (boolean8_t x) { return x ? Qtrue : Qfalse; }
+#endif
+
+#include "ca_op_powi.h"
+#include "ca_op_cmplx64.h"
+
+/* ===== cumsum_ki ============================================ */
+
+static VALUE
+cumsum_ki_native_i8 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int8_t, double, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_ki_native_u8 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint8_t, double, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_ki_native_i16 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int16_t, double, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_ki_native_u16 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint16_t, double, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_ki_native_i32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int32_t, double, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_ki_native_u32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint32_t, double, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_ki_native_i64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int64_t, double, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_ki_native_u64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint64_t, double, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_ki_native_f32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(float, double, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_ki_native_f64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(double, double, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_ki_native_cmplx64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_CMPLX128),
+                                          INT2NUM(sizeof(cmplx128_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(cmplx64_t, cmplx128_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_ki_native_cmplx128 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_CMPLX128),
+                                          INT2NUM(sizeof(cmplx128_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(cmplx128_t, cmplx128_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_ki_native_bool (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT64),
+                                          INT2NUM(sizeof(uint64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(boolean8_t, uint64_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+/* 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. */
+typedef struct {
+  ca_iter_state states[2];
+  VALUE self;
+  CArray *ca;
+  int axis;
+} cumsum_ki_native_object_frame;
+
+static VALUE
+cumsum_ki_native_object_body (VALUE arg)
+{
+  cumsum_ki_native_object_frame *fr = (cumsum_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int axis = fr->axis;
+  (void) axis;
+#define st_in (fr->states[0])
+#define st_out (fr->states[1])
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_OBJECT),
+                                          INT2NUM(sizeof(VALUE)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(VALUE, VALUE, st_in, pi, mi,
+                         st_out, po, INT2FIX(0), acc = rb_funcall(acc, rb_intern("+"), 1, v); r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+#undef st_in
+#undef st_out
+}
+
+static VALUE
+cumsum_ki_native_object (VALUE self, CArray *ca, int axis)
+{
+  cumsum_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.axis = axis;
+  return ca_iter_ensure(2, fr.states, cumsum_ki_native_object_body, (VALUE) &fr);
+}
+
+
+static VALUE
+rb_ca_cumsum_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  volatile VALUE raxis = Qnil;
+  rb_scan_options(ropt, "axis", &raxis);
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "%s: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cumsum(axis: 0)", ca_calling_method_name(), argc);
+  }
+  if ( NIL_P(raxis) ) {
+    volatile VALUE vflat = rb_funcall(self, rb_intern("flatten"), 0);
+    CArray *fsrc;
+    GetCArray(vflat, fsrc);
+    switch ( fsrc->data_type ) {
+      case CA_INT8: CA_RETURN_KEEPING(vflat, cumsum_ki_native_i8(vflat, fsrc, 0));
+      case CA_UINT8: CA_RETURN_KEEPING(vflat, cumsum_ki_native_u8(vflat, fsrc, 0));
+      case CA_INT16: CA_RETURN_KEEPING(vflat, cumsum_ki_native_i16(vflat, fsrc, 0));
+      case CA_UINT16: CA_RETURN_KEEPING(vflat, cumsum_ki_native_u16(vflat, fsrc, 0));
+      case CA_INT32: CA_RETURN_KEEPING(vflat, cumsum_ki_native_i32(vflat, fsrc, 0));
+      case CA_UINT32: CA_RETURN_KEEPING(vflat, cumsum_ki_native_u32(vflat, fsrc, 0));
+      case CA_INT64: CA_RETURN_KEEPING(vflat, cumsum_ki_native_i64(vflat, fsrc, 0));
+      case CA_UINT64: CA_RETURN_KEEPING(vflat, cumsum_ki_native_u64(vflat, fsrc, 0));
+      case CA_FLOAT32: CA_RETURN_KEEPING(vflat, cumsum_ki_native_f32(vflat, fsrc, 0));
+      case CA_FLOAT64: CA_RETURN_KEEPING(vflat, cumsum_ki_native_f64(vflat, fsrc, 0));
+      case CA_CMPLX64: CA_RETURN_KEEPING(vflat, cumsum_ki_native_cmplx64(vflat, fsrc, 0));
+      case CA_CMPLX128: CA_RETURN_KEEPING(vflat, cumsum_ki_native_cmplx128(vflat, fsrc, 0));
+      case CA_BOOLEAN: CA_RETURN_KEEPING(vflat, cumsum_ki_native_bool(vflat, fsrc, 0));
+      case CA_OBJECT: CA_RETURN_KEEPING(vflat, cumsum_ki_native_object(vflat, fsrc, 0));
+      default:
+        ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+        rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, cmplx64, cmplx128, boolean, object)", ca_calling_method_name(), ca_type_name[fsrc->data_type]);
+    }
+  }
+  if ( TYPE(raxis) == T_ARRAY ) {
+    rb_raise(rb_eArgError, "%s: axis must be a single Integer (got Array); a scan over several axes is ambiguous, chain explicitly: a.cumsum(axis: 0).cumsum(axis: 1)", ca_calling_method_name());
+  }
+  int axis = ca_normalize_axis_arg(raxis, src->ndim, NULL);
+  switch ( src->data_type ) {
+    case CA_INT8: CA_RETURN_KEEPING(self, cumsum_ki_native_i8(self, src, axis));
+    case CA_UINT8: CA_RETURN_KEEPING(self, cumsum_ki_native_u8(self, src, axis));
+    case CA_INT16: CA_RETURN_KEEPING(self, cumsum_ki_native_i16(self, src, axis));
+    case CA_UINT16: CA_RETURN_KEEPING(self, cumsum_ki_native_u16(self, src, axis));
+    case CA_INT32: CA_RETURN_KEEPING(self, cumsum_ki_native_i32(self, src, axis));
+    case CA_UINT32: CA_RETURN_KEEPING(self, cumsum_ki_native_u32(self, src, axis));
+    case CA_INT64: CA_RETURN_KEEPING(self, cumsum_ki_native_i64(self, src, axis));
+    case CA_UINT64: CA_RETURN_KEEPING(self, cumsum_ki_native_u64(self, src, axis));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, cumsum_ki_native_f32(self, src, axis));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, cumsum_ki_native_f64(self, src, axis));
+    case CA_CMPLX64: CA_RETURN_KEEPING(self, cumsum_ki_native_cmplx64(self, src, axis));
+    case CA_CMPLX128: CA_RETURN_KEEPING(self, cumsum_ki_native_cmplx128(self, src, axis));
+    case CA_BOOLEAN: CA_RETURN_KEEPING(self, cumsum_ki_native_bool(self, src, axis));
+    case CA_OBJECT: CA_RETURN_KEEPING(self, cumsum_ki_native_object(self, src, axis));
+    default:
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, cmplx64, cmplx128, boolean, object)", ca_calling_method_name(), ca_type_name[src->data_type]);
+  }
+  return Qnil;  /* unreachable */
+}
+
+/* ===== cumsum_in_own_type_ki ============================================ */
+
+static VALUE
+cumsum_in_own_type_ki_native_i8 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT8),
+                                          INT2NUM(sizeof(int8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int8_t, int8_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_in_own_type_ki_native_u8 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT8),
+                                          INT2NUM(sizeof(uint8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint8_t, uint8_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_in_own_type_ki_native_i16 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT16),
+                                          INT2NUM(sizeof(int16_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int16_t, int16_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_in_own_type_ki_native_u16 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT16),
+                                          INT2NUM(sizeof(uint16_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint16_t, uint16_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_in_own_type_ki_native_i32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT32),
+                                          INT2NUM(sizeof(int32_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int32_t, int32_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_in_own_type_ki_native_u32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT32),
+                                          INT2NUM(sizeof(uint32_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint32_t, uint32_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_in_own_type_ki_native_i64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int64_t, int64_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_in_own_type_ki_native_u64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT64),
+                                          INT2NUM(sizeof(uint64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint64_t, uint64_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+rb_ca_cumsum_in_own_type_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  volatile VALUE raxis = Qnil;
+  rb_scan_options(ropt, "axis", &raxis);
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "%s: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cumsum_in_own_type(axis: 0)", ca_calling_method_name(), argc);
+  }
+  if ( NIL_P(raxis) ) {
+    volatile VALUE vflat = rb_funcall(self, rb_intern("flatten"), 0);
+    CArray *fsrc;
+    GetCArray(vflat, fsrc);
+    switch ( fsrc->data_type ) {
+      case CA_INT8: CA_RETURN_KEEPING(vflat, cumsum_in_own_type_ki_native_i8(vflat, fsrc, 0));
+      case CA_UINT8: CA_RETURN_KEEPING(vflat, cumsum_in_own_type_ki_native_u8(vflat, fsrc, 0));
+      case CA_INT16: CA_RETURN_KEEPING(vflat, cumsum_in_own_type_ki_native_i16(vflat, fsrc, 0));
+      case CA_UINT16: CA_RETURN_KEEPING(vflat, cumsum_in_own_type_ki_native_u16(vflat, fsrc, 0));
+      case CA_INT32: CA_RETURN_KEEPING(vflat, cumsum_in_own_type_ki_native_i32(vflat, fsrc, 0));
+      case CA_UINT32: CA_RETURN_KEEPING(vflat, cumsum_in_own_type_ki_native_u32(vflat, fsrc, 0));
+      case CA_INT64: CA_RETURN_KEEPING(vflat, cumsum_in_own_type_ki_native_i64(vflat, fsrc, 0));
+      case CA_UINT64: CA_RETURN_KEEPING(vflat, cumsum_in_own_type_ki_native_u64(vflat, fsrc, 0));
+      default:
+        ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+        rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64)", ca_calling_method_name(), ca_type_name[fsrc->data_type]);
+    }
+  }
+  if ( TYPE(raxis) == T_ARRAY ) {
+    rb_raise(rb_eArgError, "%s: axis must be a single Integer (got Array); a scan over several axes is ambiguous, chain explicitly: a.cumsum_in_own_type(axis: 0).cumsum_in_own_type(axis: 1)", ca_calling_method_name());
+  }
+  int axis = ca_normalize_axis_arg(raxis, src->ndim, NULL);
+  switch ( src->data_type ) {
+    case CA_INT8: CA_RETURN_KEEPING(self, cumsum_in_own_type_ki_native_i8(self, src, axis));
+    case CA_UINT8: CA_RETURN_KEEPING(self, cumsum_in_own_type_ki_native_u8(self, src, axis));
+    case CA_INT16: CA_RETURN_KEEPING(self, cumsum_in_own_type_ki_native_i16(self, src, axis));
+    case CA_UINT16: CA_RETURN_KEEPING(self, cumsum_in_own_type_ki_native_u16(self, src, axis));
+    case CA_INT32: CA_RETURN_KEEPING(self, cumsum_in_own_type_ki_native_i32(self, src, axis));
+    case CA_UINT32: CA_RETURN_KEEPING(self, cumsum_in_own_type_ki_native_u32(self, src, axis));
+    case CA_INT64: CA_RETURN_KEEPING(self, cumsum_in_own_type_ki_native_i64(self, src, axis));
+    case CA_UINT64: CA_RETURN_KEEPING(self, cumsum_in_own_type_ki_native_u64(self, src, axis));
+    default:
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64)", ca_calling_method_name(), ca_type_name[src->data_type]);
+  }
+  return Qnil;  /* unreachable */
+}
+
+/* ===== cumprod_ki ============================================ */
+
+static VALUE
+cumprod_ki_native_i8 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int8_t, double, st_in, pi, mi,
+                         st_out, po, 1, acc *= v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumprod_ki_native_u8 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint8_t, double, st_in, pi, mi,
+                         st_out, po, 1, acc *= v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumprod_ki_native_i16 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int16_t, double, st_in, pi, mi,
+                         st_out, po, 1, acc *= v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumprod_ki_native_u16 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint16_t, double, st_in, pi, mi,
+                         st_out, po, 1, acc *= v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumprod_ki_native_i32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int32_t, double, st_in, pi, mi,
+                         st_out, po, 1, acc *= v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumprod_ki_native_u32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint32_t, double, st_in, pi, mi,
+                         st_out, po, 1, acc *= v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumprod_ki_native_i64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int64_t, double, st_in, pi, mi,
+                         st_out, po, 1, acc *= v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumprod_ki_native_u64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint64_t, double, st_in, pi, mi,
+                         st_out, po, 1, acc *= v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumprod_ki_native_f32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(float, double, st_in, pi, mi,
+                         st_out, po, 1, acc *= v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumprod_ki_native_f64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(double, double, st_in, pi, mi,
+                         st_out, po, 1, acc *= v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumprod_ki_native_cmplx64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_CMPLX128),
+                                          INT2NUM(sizeof(cmplx128_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(cmplx64_t, cmplx128_t, st_in, pi, mi,
+                         st_out, po, 1, acc *= v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumprod_ki_native_cmplx128 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_CMPLX128),
+                                          INT2NUM(sizeof(cmplx128_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(cmplx128_t, cmplx128_t, st_in, pi, mi,
+                         st_out, po, 1, acc *= v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumprod_ki_native_bool (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT64),
+                                          INT2NUM(sizeof(uint64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(boolean8_t, uint64_t, st_in, pi, mi,
+                         st_out, po, 1, acc *= v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+/* 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. */
+typedef struct {
+  ca_iter_state states[2];
+  VALUE self;
+  CArray *ca;
+  int axis;
+} cumprod_ki_native_object_frame;
+
+static VALUE
+cumprod_ki_native_object_body (VALUE arg)
+{
+  cumprod_ki_native_object_frame *fr = (cumprod_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int axis = fr->axis;
+  (void) axis;
+#define st_in (fr->states[0])
+#define st_out (fr->states[1])
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_OBJECT),
+                                          INT2NUM(sizeof(VALUE)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(VALUE, VALUE, st_in, pi, mi,
+                         st_out, po, INT2FIX(1), acc = rb_funcall(acc, rb_intern("*"), 1, v); r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+#undef st_in
+#undef st_out
+}
+
+static VALUE
+cumprod_ki_native_object (VALUE self, CArray *ca, int axis)
+{
+  cumprod_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.axis = axis;
+  return ca_iter_ensure(2, fr.states, cumprod_ki_native_object_body, (VALUE) &fr);
+}
+
+
+static VALUE
+rb_ca_cumprod_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  volatile VALUE raxis = Qnil;
+  rb_scan_options(ropt, "axis", &raxis);
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "%s: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cumprod(axis: 0)", ca_calling_method_name(), argc);
+  }
+  if ( NIL_P(raxis) ) {
+    volatile VALUE vflat = rb_funcall(self, rb_intern("flatten"), 0);
+    CArray *fsrc;
+    GetCArray(vflat, fsrc);
+    switch ( fsrc->data_type ) {
+      case CA_INT8: CA_RETURN_KEEPING(vflat, cumprod_ki_native_i8(vflat, fsrc, 0));
+      case CA_UINT8: CA_RETURN_KEEPING(vflat, cumprod_ki_native_u8(vflat, fsrc, 0));
+      case CA_INT16: CA_RETURN_KEEPING(vflat, cumprod_ki_native_i16(vflat, fsrc, 0));
+      case CA_UINT16: CA_RETURN_KEEPING(vflat, cumprod_ki_native_u16(vflat, fsrc, 0));
+      case CA_INT32: CA_RETURN_KEEPING(vflat, cumprod_ki_native_i32(vflat, fsrc, 0));
+      case CA_UINT32: CA_RETURN_KEEPING(vflat, cumprod_ki_native_u32(vflat, fsrc, 0));
+      case CA_INT64: CA_RETURN_KEEPING(vflat, cumprod_ki_native_i64(vflat, fsrc, 0));
+      case CA_UINT64: CA_RETURN_KEEPING(vflat, cumprod_ki_native_u64(vflat, fsrc, 0));
+      case CA_FLOAT32: CA_RETURN_KEEPING(vflat, cumprod_ki_native_f32(vflat, fsrc, 0));
+      case CA_FLOAT64: CA_RETURN_KEEPING(vflat, cumprod_ki_native_f64(vflat, fsrc, 0));
+      case CA_CMPLX64: CA_RETURN_KEEPING(vflat, cumprod_ki_native_cmplx64(vflat, fsrc, 0));
+      case CA_CMPLX128: CA_RETURN_KEEPING(vflat, cumprod_ki_native_cmplx128(vflat, fsrc, 0));
+      case CA_BOOLEAN: CA_RETURN_KEEPING(vflat, cumprod_ki_native_bool(vflat, fsrc, 0));
+      case CA_OBJECT: CA_RETURN_KEEPING(vflat, cumprod_ki_native_object(vflat, fsrc, 0));
+      default:
+        ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+        rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, cmplx64, cmplx128, boolean, object)", ca_calling_method_name(), ca_type_name[fsrc->data_type]);
+    }
+  }
+  if ( TYPE(raxis) == T_ARRAY ) {
+    rb_raise(rb_eArgError, "%s: axis must be a single Integer (got Array); a scan over several axes is ambiguous, chain explicitly: a.cumprod(axis: 0).cumprod(axis: 1)", ca_calling_method_name());
+  }
+  int axis = ca_normalize_axis_arg(raxis, src->ndim, NULL);
+  switch ( src->data_type ) {
+    case CA_INT8: CA_RETURN_KEEPING(self, cumprod_ki_native_i8(self, src, axis));
+    case CA_UINT8: CA_RETURN_KEEPING(self, cumprod_ki_native_u8(self, src, axis));
+    case CA_INT16: CA_RETURN_KEEPING(self, cumprod_ki_native_i16(self, src, axis));
+    case CA_UINT16: CA_RETURN_KEEPING(self, cumprod_ki_native_u16(self, src, axis));
+    case CA_INT32: CA_RETURN_KEEPING(self, cumprod_ki_native_i32(self, src, axis));
+    case CA_UINT32: CA_RETURN_KEEPING(self, cumprod_ki_native_u32(self, src, axis));
+    case CA_INT64: CA_RETURN_KEEPING(self, cumprod_ki_native_i64(self, src, axis));
+    case CA_UINT64: CA_RETURN_KEEPING(self, cumprod_ki_native_u64(self, src, axis));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, cumprod_ki_native_f32(self, src, axis));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, cumprod_ki_native_f64(self, src, axis));
+    case CA_CMPLX64: CA_RETURN_KEEPING(self, cumprod_ki_native_cmplx64(self, src, axis));
+    case CA_CMPLX128: CA_RETURN_KEEPING(self, cumprod_ki_native_cmplx128(self, src, axis));
+    case CA_BOOLEAN: CA_RETURN_KEEPING(self, cumprod_ki_native_bool(self, src, axis));
+    case CA_OBJECT: CA_RETURN_KEEPING(self, cumprod_ki_native_object(self, src, axis));
+    default:
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, cmplx64, cmplx128, boolean, object)", ca_calling_method_name(), ca_type_name[src->data_type]);
+  }
+  return Qnil;  /* unreachable */
+}
+
+/* ===== cummax_ki ============================================ */
+
+static VALUE
+cummax_ki_native_i8 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT8),
+                                          INT2NUM(sizeof(int8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(int8_t, int8_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, INT8_MIN, if (v > acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummax_ki_native_u8 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT8),
+                                          INT2NUM(sizeof(uint8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(uint8_t, uint8_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, 0, if (v > acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummax_ki_native_i16 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT16),
+                                          INT2NUM(sizeof(int16_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(int16_t, int16_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, INT16_MIN, if (v > acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummax_ki_native_u16 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT16),
+                                          INT2NUM(sizeof(uint16_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(uint16_t, uint16_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, 0, if (v > acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummax_ki_native_i32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT32),
+                                          INT2NUM(sizeof(int32_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(int32_t, int32_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, INT32_MIN, if (v > acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummax_ki_native_u32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT32),
+                                          INT2NUM(sizeof(uint32_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(uint32_t, uint32_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, 0, if (v > acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummax_ki_native_i64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(int64_t, int64_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, INT64_MIN, if (v > acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummax_ki_native_u64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT64),
+                                          INT2NUM(sizeof(uint64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(uint64_t, uint64_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, 0, if (v > acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummax_ki_native_f32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT32),
+                                          INT2NUM(sizeof(float)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(float, float, st_in, pi, mi,
+                         st_out, po, mo_fiber, NAN, acc = fmax(acc, v); r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummax_ki_native_f64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(double, double, st_in, pi, mi,
+                         st_out, po, mo_fiber, NAN, acc = fmax(acc, v); r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummax_ki_native_bool (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT64),
+                                          INT2NUM(sizeof(uint64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(boolean8_t, uint64_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, 0, if ((uint64_t) v > acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+/* 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. */
+typedef struct {
+  ca_iter_state states[2];
+  VALUE self;
+  CArray *ca;
+  int axis;
+} cummax_ki_native_object_frame;
+
+static VALUE
+cummax_ki_native_object_body (VALUE arg)
+{
+  cummax_ki_native_object_frame *fr = (cummax_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int axis = fr->axis;
+  (void) axis;
+#define st_in (fr->states[0])
+#define st_out (fr->states[1])
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_OBJECT),
+                                          INT2NUM(sizeof(VALUE)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(VALUE, VALUE, st_in, pi, mi,
+                         st_out, po, mo_fiber, Qnil, if (acc == Qnil || ca_obj_extremum_replaces(v, acc, rb_intern(">"))) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+#undef st_in
+#undef st_out
+}
+
+static VALUE
+cummax_ki_native_object (VALUE self, CArray *ca, int axis)
+{
+  cummax_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.axis = axis;
+  return ca_iter_ensure(2, fr.states, cummax_ki_native_object_body, (VALUE) &fr);
+}
+
+
+static VALUE rb_ca_cummax_ki_storage (int argc, VALUE *argv, VALUE self);
+
+static VALUE
+rb_ca_cummax_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  VALUE result;
+  GetCArray(self, src);
+  volatile VALUE _reduce_face = Qnil;   /* original Face, for output re-lift */
+  if ( ca_is_face(src) ) {
+    VALUE _face = self;
+    VALUE _st;
+    CArray *_sc;
+    ca_face_require_orderable(_face, ca_calling_method_name(), "order");
+    _st = rb_ca_strip_face_value(self);
+    GetCArray(_st, _sc);
+    _reduce_face = _face;
+    self = _st;
+    src = _sc;
+  }
+  result = rb_ca_cummax_ki_storage(argc, argv, self);
+  if ( _reduce_face != Qnil && RB_TYPE_P(result, T_ARRAY) ) {
+    /* a multi-output reduction (minmax): re-lift each output. */
+    long _i;
+    for ( _i = 0; _i < RARRAY_LEN(result); _i++ ) {
+      VALUE _r = rb_ary_entry(result, _i);
+      if ( _r == CA_UNDEF || _r == Qnil ) continue;
+      if ( rb_obj_is_kind_of(_r, rb_cCArray) ) {
+        _r = ca_face_relift_entity(_reduce_face, _r);
+      }
+      else {
+        CArray *_fca;
+        GetCArray(_reduce_face, _fca);
+        CA_FACE_STORAGE_TO_ELEMENT_IF_FACE(_r, _reduce_face, _fca);
+      }
+      rb_ary_store(result, _i, _r);
+    }
+  }
+  else if ( _reduce_face != Qnil && result != CA_UNDEF && result != Qnil ) {
+    if ( rb_obj_is_kind_of(result, rb_cCArray) ) {
+      /* per-axis: re-lift the storage result as a Face of the same class. */
+      result = ca_face_relift_entity(_reduce_face, result);
+    }
+    else {
+      /* full reduction: decode the scalar via the registered hook. */
+      CArray *_fca;
+      GetCArray(_reduce_face, _fca);
+      CA_FACE_STORAGE_TO_ELEMENT_IF_FACE(result, _reduce_face, _fca);
+    }
+  }
+  return result;
+}
+
+static VALUE
+rb_ca_cummax_ki_storage (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  volatile VALUE raxis = Qnil;
+  rb_scan_options(ropt, "axis", &raxis);
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "%s: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cummax(axis: 0)", ca_calling_method_name(), argc);
+  }
+  if ( NIL_P(raxis) ) {
+    volatile VALUE vflat = rb_funcall(self, rb_intern("flatten"), 0);
+    CArray *fsrc;
+    GetCArray(vflat, fsrc);
+    switch ( fsrc->data_type ) {
+      case CA_INT8: CA_RETURN_KEEPING(vflat, cummax_ki_native_i8(vflat, fsrc, 0));
+      case CA_UINT8: CA_RETURN_KEEPING(vflat, cummax_ki_native_u8(vflat, fsrc, 0));
+      case CA_INT16: CA_RETURN_KEEPING(vflat, cummax_ki_native_i16(vflat, fsrc, 0));
+      case CA_UINT16: CA_RETURN_KEEPING(vflat, cummax_ki_native_u16(vflat, fsrc, 0));
+      case CA_INT32: CA_RETURN_KEEPING(vflat, cummax_ki_native_i32(vflat, fsrc, 0));
+      case CA_UINT32: CA_RETURN_KEEPING(vflat, cummax_ki_native_u32(vflat, fsrc, 0));
+      case CA_INT64: CA_RETURN_KEEPING(vflat, cummax_ki_native_i64(vflat, fsrc, 0));
+      case CA_UINT64: CA_RETURN_KEEPING(vflat, cummax_ki_native_u64(vflat, fsrc, 0));
+      case CA_FLOAT32: CA_RETURN_KEEPING(vflat, cummax_ki_native_f32(vflat, fsrc, 0));
+      case CA_FLOAT64: CA_RETURN_KEEPING(vflat, cummax_ki_native_f64(vflat, fsrc, 0));
+      case CA_BOOLEAN: CA_RETURN_KEEPING(vflat, cummax_ki_native_bool(vflat, fsrc, 0));
+      case CA_OBJECT: CA_RETURN_KEEPING(vflat, cummax_ki_native_object(vflat, fsrc, 0));
+      default:
+        ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+        rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, boolean, object)", ca_calling_method_name(), ca_type_name[fsrc->data_type]);
+    }
+  }
+  if ( TYPE(raxis) == T_ARRAY ) {
+    rb_raise(rb_eArgError, "%s: axis must be a single Integer (got Array); a scan over several axes is ambiguous, chain explicitly: a.cummax(axis: 0).cummax(axis: 1)", ca_calling_method_name());
+  }
+  int axis = ca_normalize_axis_arg(raxis, src->ndim, NULL);
+  switch ( src->data_type ) {
+    case CA_INT8: CA_RETURN_KEEPING(self, cummax_ki_native_i8(self, src, axis));
+    case CA_UINT8: CA_RETURN_KEEPING(self, cummax_ki_native_u8(self, src, axis));
+    case CA_INT16: CA_RETURN_KEEPING(self, cummax_ki_native_i16(self, src, axis));
+    case CA_UINT16: CA_RETURN_KEEPING(self, cummax_ki_native_u16(self, src, axis));
+    case CA_INT32: CA_RETURN_KEEPING(self, cummax_ki_native_i32(self, src, axis));
+    case CA_UINT32: CA_RETURN_KEEPING(self, cummax_ki_native_u32(self, src, axis));
+    case CA_INT64: CA_RETURN_KEEPING(self, cummax_ki_native_i64(self, src, axis));
+    case CA_UINT64: CA_RETURN_KEEPING(self, cummax_ki_native_u64(self, src, axis));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, cummax_ki_native_f32(self, src, axis));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, cummax_ki_native_f64(self, src, axis));
+    case CA_BOOLEAN: CA_RETURN_KEEPING(self, cummax_ki_native_bool(self, src, axis));
+    case CA_OBJECT: CA_RETURN_KEEPING(self, cummax_ki_native_object(self, src, axis));
+    default:
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, boolean, object)", ca_calling_method_name(), ca_type_name[src->data_type]);
+  }
+  return Qnil;  /* unreachable */
+}
+
+/* ===== cummin_ki ============================================ */
+
+static VALUE
+cummin_ki_native_i8 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT8),
+                                          INT2NUM(sizeof(int8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(int8_t, int8_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, INT8_MAX, if (v < acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummin_ki_native_u8 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT8),
+                                          INT2NUM(sizeof(uint8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(uint8_t, uint8_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, UINT8_MAX, if (v < acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummin_ki_native_i16 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT16),
+                                          INT2NUM(sizeof(int16_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(int16_t, int16_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, INT16_MAX, if (v < acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummin_ki_native_u16 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT16),
+                                          INT2NUM(sizeof(uint16_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(uint16_t, uint16_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, UINT16_MAX, if (v < acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummin_ki_native_i32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT32),
+                                          INT2NUM(sizeof(int32_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(int32_t, int32_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, INT32_MAX, if (v < acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummin_ki_native_u32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT32),
+                                          INT2NUM(sizeof(uint32_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(uint32_t, uint32_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, UINT32_MAX, if (v < acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummin_ki_native_i64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(int64_t, int64_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, INT64_MAX, if (v < acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummin_ki_native_u64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT64),
+                                          INT2NUM(sizeof(uint64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(uint64_t, uint64_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, UINT64_MAX, if (v < acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummin_ki_native_f32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT32),
+                                          INT2NUM(sizeof(float)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(float, float, st_in, pi, mi,
+                         st_out, po, mo_fiber, NAN, acc = fmin(acc, v); r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummin_ki_native_f64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(double, double, st_in, pi, mi,
+                         st_out, po, mo_fiber, NAN, acc = fmin(acc, v); r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cummin_ki_native_bool (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT64),
+                                          INT2NUM(sizeof(uint64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(boolean8_t, uint64_t, st_in, pi, mi,
+                         st_out, po, mo_fiber, 1, if ((uint64_t) v < acc) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+/* 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. */
+typedef struct {
+  ca_iter_state states[2];
+  VALUE self;
+  CArray *ca;
+  int axis;
+} cummin_ki_native_object_frame;
+
+static VALUE
+cummin_ki_native_object_body (VALUE arg)
+{
+  cummin_ki_native_object_frame *fr = (cummin_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int axis = fr->axis;
+  (void) axis;
+#define st_in (fr->states[0])
+#define st_out (fr->states[1])
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_OBJECT),
+                                          INT2NUM(sizeof(VALUE)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    if ( ca_has_mask(ca) ) {
+      ca_create_mask(co);
+      op_mask = (boolean8_t *) co->mask->ptr;
+    }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    boolean8_t *mo_fiber = op_mask
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(VALUE, VALUE, st_in, pi, mi,
+                         st_out, po, mo_fiber, Qnil, if (acc == Qnil || ca_obj_extremum_replaces(v, acc, rb_intern("<"))) acc = v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+#undef st_in
+#undef st_out
+}
+
+static VALUE
+cummin_ki_native_object (VALUE self, CArray *ca, int axis)
+{
+  cummin_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.axis = axis;
+  return ca_iter_ensure(2, fr.states, cummin_ki_native_object_body, (VALUE) &fr);
+}
+
+
+static VALUE rb_ca_cummin_ki_storage (int argc, VALUE *argv, VALUE self);
+
+static VALUE
+rb_ca_cummin_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  VALUE result;
+  GetCArray(self, src);
+  volatile VALUE _reduce_face = Qnil;   /* original Face, for output re-lift */
+  if ( ca_is_face(src) ) {
+    VALUE _face = self;
+    VALUE _st;
+    CArray *_sc;
+    ca_face_require_orderable(_face, ca_calling_method_name(), "order");
+    _st = rb_ca_strip_face_value(self);
+    GetCArray(_st, _sc);
+    _reduce_face = _face;
+    self = _st;
+    src = _sc;
+  }
+  result = rb_ca_cummin_ki_storage(argc, argv, self);
+  if ( _reduce_face != Qnil && RB_TYPE_P(result, T_ARRAY) ) {
+    /* a multi-output reduction (minmax): re-lift each output. */
+    long _i;
+    for ( _i = 0; _i < RARRAY_LEN(result); _i++ ) {
+      VALUE _r = rb_ary_entry(result, _i);
+      if ( _r == CA_UNDEF || _r == Qnil ) continue;
+      if ( rb_obj_is_kind_of(_r, rb_cCArray) ) {
+        _r = ca_face_relift_entity(_reduce_face, _r);
+      }
+      else {
+        CArray *_fca;
+        GetCArray(_reduce_face, _fca);
+        CA_FACE_STORAGE_TO_ELEMENT_IF_FACE(_r, _reduce_face, _fca);
+      }
+      rb_ary_store(result, _i, _r);
+    }
+  }
+  else if ( _reduce_face != Qnil && result != CA_UNDEF && result != Qnil ) {
+    if ( rb_obj_is_kind_of(result, rb_cCArray) ) {
+      /* per-axis: re-lift the storage result as a Face of the same class. */
+      result = ca_face_relift_entity(_reduce_face, result);
+    }
+    else {
+      /* full reduction: decode the scalar via the registered hook. */
+      CArray *_fca;
+      GetCArray(_reduce_face, _fca);
+      CA_FACE_STORAGE_TO_ELEMENT_IF_FACE(result, _reduce_face, _fca);
+    }
+  }
+  return result;
+}
+
+static VALUE
+rb_ca_cummin_ki_storage (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  volatile VALUE raxis = Qnil;
+  rb_scan_options(ropt, "axis", &raxis);
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "%s: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cummin(axis: 0)", ca_calling_method_name(), argc);
+  }
+  if ( NIL_P(raxis) ) {
+    volatile VALUE vflat = rb_funcall(self, rb_intern("flatten"), 0);
+    CArray *fsrc;
+    GetCArray(vflat, fsrc);
+    switch ( fsrc->data_type ) {
+      case CA_INT8: CA_RETURN_KEEPING(vflat, cummin_ki_native_i8(vflat, fsrc, 0));
+      case CA_UINT8: CA_RETURN_KEEPING(vflat, cummin_ki_native_u8(vflat, fsrc, 0));
+      case CA_INT16: CA_RETURN_KEEPING(vflat, cummin_ki_native_i16(vflat, fsrc, 0));
+      case CA_UINT16: CA_RETURN_KEEPING(vflat, cummin_ki_native_u16(vflat, fsrc, 0));
+      case CA_INT32: CA_RETURN_KEEPING(vflat, cummin_ki_native_i32(vflat, fsrc, 0));
+      case CA_UINT32: CA_RETURN_KEEPING(vflat, cummin_ki_native_u32(vflat, fsrc, 0));
+      case CA_INT64: CA_RETURN_KEEPING(vflat, cummin_ki_native_i64(vflat, fsrc, 0));
+      case CA_UINT64: CA_RETURN_KEEPING(vflat, cummin_ki_native_u64(vflat, fsrc, 0));
+      case CA_FLOAT32: CA_RETURN_KEEPING(vflat, cummin_ki_native_f32(vflat, fsrc, 0));
+      case CA_FLOAT64: CA_RETURN_KEEPING(vflat, cummin_ki_native_f64(vflat, fsrc, 0));
+      case CA_BOOLEAN: CA_RETURN_KEEPING(vflat, cummin_ki_native_bool(vflat, fsrc, 0));
+      case CA_OBJECT: CA_RETURN_KEEPING(vflat, cummin_ki_native_object(vflat, fsrc, 0));
+      default:
+        ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+        rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, boolean, object)", ca_calling_method_name(), ca_type_name[fsrc->data_type]);
+    }
+  }
+  if ( TYPE(raxis) == T_ARRAY ) {
+    rb_raise(rb_eArgError, "%s: axis must be a single Integer (got Array); a scan over several axes is ambiguous, chain explicitly: a.cummin(axis: 0).cummin(axis: 1)", ca_calling_method_name());
+  }
+  int axis = ca_normalize_axis_arg(raxis, src->ndim, NULL);
+  switch ( src->data_type ) {
+    case CA_INT8: CA_RETURN_KEEPING(self, cummin_ki_native_i8(self, src, axis));
+    case CA_UINT8: CA_RETURN_KEEPING(self, cummin_ki_native_u8(self, src, axis));
+    case CA_INT16: CA_RETURN_KEEPING(self, cummin_ki_native_i16(self, src, axis));
+    case CA_UINT16: CA_RETURN_KEEPING(self, cummin_ki_native_u16(self, src, axis));
+    case CA_INT32: CA_RETURN_KEEPING(self, cummin_ki_native_i32(self, src, axis));
+    case CA_UINT32: CA_RETURN_KEEPING(self, cummin_ki_native_u32(self, src, axis));
+    case CA_INT64: CA_RETURN_KEEPING(self, cummin_ki_native_i64(self, src, axis));
+    case CA_UINT64: CA_RETURN_KEEPING(self, cummin_ki_native_u64(self, src, axis));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, cummin_ki_native_f32(self, src, axis));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, cummin_ki_native_f64(self, src, axis));
+    case CA_BOOLEAN: CA_RETURN_KEEPING(self, cummin_ki_native_bool(self, src, axis));
+    case CA_OBJECT: CA_RETURN_KEEPING(self, cummin_ki_native_object(self, src, axis));
+    default:
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, boolean, object)", ca_calling_method_name(), ca_type_name[src->data_type]);
+  }
+  return Qnil;  /* unreachable */
+}
+
+/* ===== cumcount_ki ============================================ */
+
+static VALUE
+cumcount_ki_native_i8 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int8_t, int64_t, st_in, pi, mi,
+                         st_out, po, 0, (void) v; r = ++acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumcount_ki_native_u8 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint8_t, int64_t, st_in, pi, mi,
+                         st_out, po, 0, (void) v; r = ++acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumcount_ki_native_i16 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int16_t, int64_t, st_in, pi, mi,
+                         st_out, po, 0, (void) v; r = ++acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumcount_ki_native_u16 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint16_t, int64_t, st_in, pi, mi,
+                         st_out, po, 0, (void) v; r = ++acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumcount_ki_native_i32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int32_t, int64_t, st_in, pi, mi,
+                         st_out, po, 0, (void) v; r = ++acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumcount_ki_native_u32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint32_t, int64_t, st_in, pi, mi,
+                         st_out, po, 0, (void) v; r = ++acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumcount_ki_native_i64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int64_t, int64_t, st_in, pi, mi,
+                         st_out, po, 0, (void) v; r = ++acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumcount_ki_native_u64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint64_t, int64_t, st_in, pi, mi,
+                         st_out, po, 0, (void) v; r = ++acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumcount_ki_native_f32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(float, int64_t, st_in, pi, mi,
+                         st_out, po, 0, (void) v; r = ++acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumcount_ki_native_f64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(double, int64_t, st_in, pi, mi,
+                         st_out, po, 0, (void) v; r = ++acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+rb_ca_cumcount_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  volatile VALUE raxis = Qnil;
+  rb_scan_options(ropt, "axis", &raxis);
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "%s: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cumcount(axis: 0)", ca_calling_method_name(), argc);
+  }
+  if ( NIL_P(raxis) ) {
+    volatile VALUE vflat = rb_funcall(self, rb_intern("flatten"), 0);
+    CArray *fsrc;
+    GetCArray(vflat, fsrc);
+    switch ( fsrc->data_type ) {
+      case CA_INT8: CA_RETURN_KEEPING(vflat, cumcount_ki_native_i8(vflat, fsrc, 0));
+      case CA_UINT8: CA_RETURN_KEEPING(vflat, cumcount_ki_native_u8(vflat, fsrc, 0));
+      case CA_INT16: CA_RETURN_KEEPING(vflat, cumcount_ki_native_i16(vflat, fsrc, 0));
+      case CA_UINT16: CA_RETURN_KEEPING(vflat, cumcount_ki_native_u16(vflat, fsrc, 0));
+      case CA_INT32: CA_RETURN_KEEPING(vflat, cumcount_ki_native_i32(vflat, fsrc, 0));
+      case CA_UINT32: CA_RETURN_KEEPING(vflat, cumcount_ki_native_u32(vflat, fsrc, 0));
+      case CA_INT64: CA_RETURN_KEEPING(vflat, cumcount_ki_native_i64(vflat, fsrc, 0));
+      case CA_UINT64: CA_RETURN_KEEPING(vflat, cumcount_ki_native_u64(vflat, fsrc, 0));
+      case CA_FLOAT32: CA_RETURN_KEEPING(vflat, cumcount_ki_native_f32(vflat, fsrc, 0));
+      case CA_FLOAT64: CA_RETURN_KEEPING(vflat, cumcount_ki_native_f64(vflat, fsrc, 0));
+      default:
+        return rb_ca_scan_mask_count(self, Qnil);
+    }
+  }
+  if ( TYPE(raxis) == T_ARRAY ) {
+    rb_raise(rb_eArgError, "%s: axis must be a single Integer (got Array); a scan over several axes is ambiguous, chain explicitly: a.cumcount(axis: 0).cumcount(axis: 1)", ca_calling_method_name());
+  }
+  int axis = ca_normalize_axis_arg(raxis, src->ndim, NULL);
+  switch ( src->data_type ) {
+    case CA_INT8: CA_RETURN_KEEPING(self, cumcount_ki_native_i8(self, src, axis));
+    case CA_UINT8: CA_RETURN_KEEPING(self, cumcount_ki_native_u8(self, src, axis));
+    case CA_INT16: CA_RETURN_KEEPING(self, cumcount_ki_native_i16(self, src, axis));
+    case CA_UINT16: CA_RETURN_KEEPING(self, cumcount_ki_native_u16(self, src, axis));
+    case CA_INT32: CA_RETURN_KEEPING(self, cumcount_ki_native_i32(self, src, axis));
+    case CA_UINT32: CA_RETURN_KEEPING(self, cumcount_ki_native_u32(self, src, axis));
+    case CA_INT64: CA_RETURN_KEEPING(self, cumcount_ki_native_i64(self, src, axis));
+    case CA_UINT64: CA_RETURN_KEEPING(self, cumcount_ki_native_u64(self, src, axis));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, cumcount_ki_native_f32(self, src, axis));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, cumcount_ki_native_f64(self, src, axis));
+    default:
+      return rb_ca_scan_mask_count(self, INT2NUM(axis));
+  }
+  return Qnil;  /* unreachable */
+}
+
+/* ===== uniq_scan_ki ============================================ */
+
+static VALUE
+uniq_scan_ki_native_i8 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_BOOLEAN),
+                                          INT2NUM(sizeof(boolean8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_TA(int8_t, boolean8_t, int8_t, st_in, pi, mi,
+                         st_out, po, 0, if (first) { acc = v; r = 0; } else if (v == acc) { r = 1; } else { acc = v; r = 0; });
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+uniq_scan_ki_native_u8 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_BOOLEAN),
+                                          INT2NUM(sizeof(boolean8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_TA(uint8_t, boolean8_t, uint8_t, st_in, pi, mi,
+                         st_out, po, 0, if (first) { acc = v; r = 0; } else if (v == acc) { r = 1; } else { acc = v; r = 0; });
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+uniq_scan_ki_native_i16 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_BOOLEAN),
+                                          INT2NUM(sizeof(boolean8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_TA(int16_t, boolean8_t, int16_t, st_in, pi, mi,
+                         st_out, po, 0, if (first) { acc = v; r = 0; } else if (v == acc) { r = 1; } else { acc = v; r = 0; });
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+uniq_scan_ki_native_u16 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_BOOLEAN),
+                                          INT2NUM(sizeof(boolean8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_TA(uint16_t, boolean8_t, uint16_t, st_in, pi, mi,
+                         st_out, po, 0, if (first) { acc = v; r = 0; } else if (v == acc) { r = 1; } else { acc = v; r = 0; });
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+uniq_scan_ki_native_i32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_BOOLEAN),
+                                          INT2NUM(sizeof(boolean8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_TA(int32_t, boolean8_t, int32_t, st_in, pi, mi,
+                         st_out, po, 0, if (first) { acc = v; r = 0; } else if (v == acc) { r = 1; } else { acc = v; r = 0; });
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+uniq_scan_ki_native_u32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_BOOLEAN),
+                                          INT2NUM(sizeof(boolean8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_TA(uint32_t, boolean8_t, uint32_t, st_in, pi, mi,
+                         st_out, po, 0, if (first) { acc = v; r = 0; } else if (v == acc) { r = 1; } else { acc = v; r = 0; });
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+uniq_scan_ki_native_i64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_BOOLEAN),
+                                          INT2NUM(sizeof(boolean8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_TA(int64_t, boolean8_t, int64_t, st_in, pi, mi,
+                         st_out, po, 0, if (first) { acc = v; r = 0; } else if (v == acc) { r = 1; } else { acc = v; r = 0; });
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+uniq_scan_ki_native_u64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_BOOLEAN),
+                                          INT2NUM(sizeof(boolean8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_TA(uint64_t, boolean8_t, uint64_t, st_in, pi, mi,
+                         st_out, po, 0, if (first) { acc = v; r = 0; } else if (v == acc) { r = 1; } else { acc = v; r = 0; });
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+uniq_scan_ki_native_f32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_BOOLEAN),
+                                          INT2NUM(sizeof(boolean8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_TA(float, boolean8_t, float, st_in, pi, mi,
+                         st_out, po, 0, if (first) { acc = v; r = 0; } else if (v == acc) { r = 1; } else { acc = v; r = 0; });
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+uniq_scan_ki_native_f64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_BOOLEAN),
+                                          INT2NUM(sizeof(boolean8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_TA(double, boolean8_t, double, st_in, pi, mi,
+                         st_out, po, 0, if (first) { acc = v; r = 0; } else if (v == acc) { r = 1; } else { acc = v; r = 0; });
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+rb_ca_uniq_scan_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  volatile VALUE raxis = Qnil;
+  rb_scan_options(ropt, "axis", &raxis);
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "%s: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.uniq_scan(axis: 0)", ca_calling_method_name(), argc);
+  }
+  if ( NIL_P(raxis) ) {
+    rb_raise(rb_eArgError, "%s: axis: is required (a single Integer; a scan over several axes is ambiguous)", ca_calling_method_name());
+  }
+  if ( TYPE(raxis) == T_ARRAY ) {
+    rb_raise(rb_eArgError, "%s: axis must be a single Integer (got Array); a scan over several axes is ambiguous, chain explicitly: a.uniq_scan(axis: 0).uniq_scan(axis: 1)", ca_calling_method_name());
+  }
+  int axis = ca_normalize_axis_arg(raxis, src->ndim, NULL);
+  switch ( src->data_type ) {
+    case CA_INT8: CA_RETURN_KEEPING(self, uniq_scan_ki_native_i8(self, src, axis));
+    case CA_UINT8: CA_RETURN_KEEPING(self, uniq_scan_ki_native_u8(self, src, axis));
+    case CA_INT16: CA_RETURN_KEEPING(self, uniq_scan_ki_native_i16(self, src, axis));
+    case CA_UINT16: CA_RETURN_KEEPING(self, uniq_scan_ki_native_u16(self, src, axis));
+    case CA_INT32: CA_RETURN_KEEPING(self, uniq_scan_ki_native_i32(self, src, axis));
+    case CA_UINT32: CA_RETURN_KEEPING(self, uniq_scan_ki_native_u32(self, src, axis));
+    case CA_INT64: CA_RETURN_KEEPING(self, uniq_scan_ki_native_i64(self, src, axis));
+    case CA_UINT64: CA_RETURN_KEEPING(self, uniq_scan_ki_native_u64(self, src, axis));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, uniq_scan_ki_native_f32(self, src, axis));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, uniq_scan_ki_native_f64(self, src, axis));
+    default:
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64)", ca_calling_method_name(), ca_type_name[src->data_type]);
+  }
+  return Qnil;  /* unreachable */
+}
+
+void
+Init_carray_kernels_scan (void)
+{
+  rb_define_method(rb_cCArray, "cumsum_ki", rb_ca_cumsum_ki, -1);
+  rb_define_method(rb_cCArray, "cumsum", rb_ca_cumsum_ki, -1);
+  rb_define_private_method(rb_cCArray, "cumsum_in_own_type", rb_ca_cumsum_in_own_type_ki, -1);
+  rb_define_method(rb_cCArray, "cumprod_ki", rb_ca_cumprod_ki, -1);
+  rb_define_method(rb_cCArray, "cumprod", rb_ca_cumprod_ki, -1);
+  rb_define_method(rb_cCArray, "cummax_ki", rb_ca_cummax_ki, -1);
+  rb_define_method(rb_cCArray, "cummax", rb_ca_cummax_ki, -1);
+  rb_define_method(rb_cCArray, "cummin_ki", rb_ca_cummin_ki, -1);
+  rb_define_method(rb_cCArray, "cummin", rb_ca_cummin_ki, -1);
+  rb_define_method(rb_cCArray, "cumcount_ki", rb_ca_cumcount_ki, -1);
+  rb_define_method(rb_cCArray, "cumcount", rb_ca_cumcount_ki, -1);
+  rb_define_method(rb_cCArray, "uniq_scan_ki", rb_ca_uniq_scan_ki, -1);
+}