carray 2.0.1 → 3.0.1

data/ext/carray_kernels_scan.c

@@ -0,0 +1,3693 @@
+/* ---------------------------------------------------------------------------
+
+   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;
+/* 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,
+             "cumsum_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumsum_ki: output init failed rc=%d", 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,
+             "cumsum_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumsum_ki: output init failed rc=%d", 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,
+             "cumsum_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumsum_ki: output init failed rc=%d", 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,
+             "cumsum_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumsum_ki: output init failed rc=%d", 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,
+             "cumsum_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumsum_ki: output init failed rc=%d", 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,
+             "cumsum_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumsum_ki: output init failed rc=%d", 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,
+             "cumsum_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumsum_ki: output init failed rc=%d", 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,
+             "cumsum_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumsum_ki: output init failed rc=%d", 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,
+             "cumsum_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumsum_ki: output init failed rc=%d", 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,
+             "cumsum_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumsum_ki: output init failed rc=%d", 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,
+             "cumsum_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumsum_ki: output init failed rc=%d", 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,
+             "cumsum_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumsum_ki: output init failed rc=%d", 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,
+             "cumsum_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumsum_ki: output init failed rc=%d", 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;
+}
+
+static VALUE
+cumsum_ki_native_object (VALUE self, CArray *ca, int axis)
+{
+  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;
+  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,
+             "cumsum_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumsum_ki: output init failed rc=%d", 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;
+}
+
+static VALUE
+rb_ca_cumsum_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  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, "cumsum_ki: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cumsum(axis: 0)", 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: return cumsum_ki_native_i8(vflat, fsrc, 0);
+      case CA_UINT8: return cumsum_ki_native_u8(vflat, fsrc, 0);
+      case CA_INT16: return cumsum_ki_native_i16(vflat, fsrc, 0);
+      case CA_UINT16: return cumsum_ki_native_u16(vflat, fsrc, 0);
+      case CA_INT32: return cumsum_ki_native_i32(vflat, fsrc, 0);
+      case CA_UINT32: return cumsum_ki_native_u32(vflat, fsrc, 0);
+      case CA_INT64: return cumsum_ki_native_i64(vflat, fsrc, 0);
+      case CA_UINT64: return cumsum_ki_native_u64(vflat, fsrc, 0);
+      case CA_FLOAT32: return cumsum_ki_native_f32(vflat, fsrc, 0);
+      case CA_FLOAT64: return cumsum_ki_native_f64(vflat, fsrc, 0);
+      case CA_CMPLX64: return cumsum_ki_native_cmplx64(vflat, fsrc, 0);
+      case CA_CMPLX128: return cumsum_ki_native_cmplx128(vflat, fsrc, 0);
+      case CA_BOOLEAN: return cumsum_ki_native_bool(vflat, fsrc, 0);
+      case CA_OBJECT: return cumsum_ki_native_object(vflat, fsrc, 0);
+      default:
+        rb_raise(rb_eCADataTypeError, "cumsum_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, cmplx64, cmplx128, bool, object)", ca_type_name[fsrc->data_type]);
+    }
+  }
+  if ( TYPE(raxis) == T_ARRAY ) {
+    rb_raise(rb_eArgError, "cumsum_ki: axis: must be Integer (got Array); multi-axis scan is semantically ambiguous, chain explicitly: a.cumsum(axis: 0).cumsum(axis: 1)");
+  }
+  if ( ! rb_obj_is_kind_of(raxis, rb_cInteger) ) {
+    rb_raise(rb_eTypeError, "cumsum_ki: axis: must be Integer (got %"PRIsVALUE")", rb_obj_class(raxis));
+  }
+  int axis = NUM2INT(raxis);
+  if ( axis < 0 ) axis += src->ndim;
+  if ( axis < 0 || axis >= src->ndim ) {
+    rb_raise(rb_eArgError, "cumsum_ki: axis %d out of range for ndim %d", NUM2INT(raxis), src->ndim);
+  }
+  switch ( src->data_type ) {
+    case CA_INT8: return cumsum_ki_native_i8(self, src, axis);
+    case CA_UINT8: return cumsum_ki_native_u8(self, src, axis);
+    case CA_INT16: return cumsum_ki_native_i16(self, src, axis);
+    case CA_UINT16: return cumsum_ki_native_u16(self, src, axis);
+    case CA_INT32: return cumsum_ki_native_i32(self, src, axis);
+    case CA_UINT32: return cumsum_ki_native_u32(self, src, axis);
+    case CA_INT64: return cumsum_ki_native_i64(self, src, axis);
+    case CA_UINT64: return cumsum_ki_native_u64(self, src, axis);
+    case CA_FLOAT32: return cumsum_ki_native_f32(self, src, axis);
+    case CA_FLOAT64: return cumsum_ki_native_f64(self, src, axis);
+    case CA_CMPLX64: return cumsum_ki_native_cmplx64(self, src, axis);
+    case CA_CMPLX128: return cumsum_ki_native_cmplx128(self, src, axis);
+    case CA_BOOLEAN: return cumsum_ki_native_bool(self, src, axis);
+    case CA_OBJECT: return cumsum_ki_native_object(self, src, axis);
+    default:
+      rb_raise(rb_eCADataTypeError, "cumsum_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, cmplx64, cmplx128, bool, object)", 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,
+             "cumprod_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumprod_ki: output init failed rc=%d", 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,
+             "cumprod_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumprod_ki: output init failed rc=%d", 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,
+             "cumprod_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumprod_ki: output init failed rc=%d", 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,
+             "cumprod_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumprod_ki: output init failed rc=%d", 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,
+             "cumprod_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumprod_ki: output init failed rc=%d", 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,
+             "cumprod_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumprod_ki: output init failed rc=%d", 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,
+             "cumprod_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumprod_ki: output init failed rc=%d", 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,
+             "cumprod_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumprod_ki: output init failed rc=%d", 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,
+             "cumprod_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumprod_ki: output init failed rc=%d", 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,
+             "cumprod_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumprod_ki: output init failed rc=%d", 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,
+             "cumprod_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumprod_ki: output init failed rc=%d", 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,
+             "cumprod_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumprod_ki: output init failed rc=%d", 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,
+             "cumprod_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumprod_ki: output init failed rc=%d", 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;
+}
+
+static VALUE
+cumprod_ki_native_object (VALUE self, CArray *ca, int axis)
+{
+  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;
+  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,
+             "cumprod_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumprod_ki: output init failed rc=%d", 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;
+}
+
+static VALUE
+rb_ca_cumprod_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  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, "cumprod_ki: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cumprod(axis: 0)", 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: return cumprod_ki_native_i8(vflat, fsrc, 0);
+      case CA_UINT8: return cumprod_ki_native_u8(vflat, fsrc, 0);
+      case CA_INT16: return cumprod_ki_native_i16(vflat, fsrc, 0);
+      case CA_UINT16: return cumprod_ki_native_u16(vflat, fsrc, 0);
+      case CA_INT32: return cumprod_ki_native_i32(vflat, fsrc, 0);
+      case CA_UINT32: return cumprod_ki_native_u32(vflat, fsrc, 0);
+      case CA_INT64: return cumprod_ki_native_i64(vflat, fsrc, 0);
+      case CA_UINT64: return cumprod_ki_native_u64(vflat, fsrc, 0);
+      case CA_FLOAT32: return cumprod_ki_native_f32(vflat, fsrc, 0);
+      case CA_FLOAT64: return cumprod_ki_native_f64(vflat, fsrc, 0);
+      case CA_CMPLX64: return cumprod_ki_native_cmplx64(vflat, fsrc, 0);
+      case CA_CMPLX128: return cumprod_ki_native_cmplx128(vflat, fsrc, 0);
+      case CA_BOOLEAN: return cumprod_ki_native_bool(vflat, fsrc, 0);
+      case CA_OBJECT: return cumprod_ki_native_object(vflat, fsrc, 0);
+      default:
+        rb_raise(rb_eCADataTypeError, "cumprod_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, cmplx64, cmplx128, bool, object)", ca_type_name[fsrc->data_type]);
+    }
+  }
+  if ( TYPE(raxis) == T_ARRAY ) {
+    rb_raise(rb_eArgError, "cumprod_ki: axis: must be Integer (got Array); multi-axis scan is semantically ambiguous, chain explicitly: a.cumprod(axis: 0).cumprod(axis: 1)");
+  }
+  if ( ! rb_obj_is_kind_of(raxis, rb_cInteger) ) {
+    rb_raise(rb_eTypeError, "cumprod_ki: axis: must be Integer (got %"PRIsVALUE")", rb_obj_class(raxis));
+  }
+  int axis = NUM2INT(raxis);
+  if ( axis < 0 ) axis += src->ndim;
+  if ( axis < 0 || axis >= src->ndim ) {
+    rb_raise(rb_eArgError, "cumprod_ki: axis %d out of range for ndim %d", NUM2INT(raxis), src->ndim);
+  }
+  switch ( src->data_type ) {
+    case CA_INT8: return cumprod_ki_native_i8(self, src, axis);
+    case CA_UINT8: return cumprod_ki_native_u8(self, src, axis);
+    case CA_INT16: return cumprod_ki_native_i16(self, src, axis);
+    case CA_UINT16: return cumprod_ki_native_u16(self, src, axis);
+    case CA_INT32: return cumprod_ki_native_i32(self, src, axis);
+    case CA_UINT32: return cumprod_ki_native_u32(self, src, axis);
+    case CA_INT64: return cumprod_ki_native_i64(self, src, axis);
+    case CA_UINT64: return cumprod_ki_native_u64(self, src, axis);
+    case CA_FLOAT32: return cumprod_ki_native_f32(self, src, axis);
+    case CA_FLOAT64: return cumprod_ki_native_f64(self, src, axis);
+    case CA_CMPLX64: return cumprod_ki_native_cmplx64(self, src, axis);
+    case CA_CMPLX128: return cumprod_ki_native_cmplx128(self, src, axis);
+    case CA_BOOLEAN: return cumprod_ki_native_bool(self, src, axis);
+    case CA_OBJECT: return cumprod_ki_native_object(self, src, axis);
+    default:
+      rb_raise(rb_eCADataTypeError, "cumprod_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, cmplx64, cmplx128, bool, object)", 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,
+             "cummax_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummax_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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,
+             "cummax_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummax_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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,
+             "cummax_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummax_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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,
+             "cummax_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummax_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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,
+             "cummax_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummax_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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,
+             "cummax_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummax_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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,
+             "cummax_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummax_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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,
+             "cummax_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummax_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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,
+             "cummax_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummax_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(float, float, st_in, pi, mi,
+                         st_out, po, mo_fiber, -INFINITY, 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_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,
+             "cummax_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummax_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(double, double, st_in, pi, mi,
+                         st_out, po, mo_fiber, -INFINITY, 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_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,
+             "cummax_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummax_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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;
+}
+
+static VALUE
+cummax_ki_native_object (VALUE self, CArray *ca, int axis)
+{
+  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;
+  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,
+             "cummax_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummax_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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) acc = v; else if (RTEST(rb_funcall(v, rb_intern(">"), 1, 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
+rb_ca_cummax_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  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, "cummax_ki: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cummax(axis: 0)", 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: return cummax_ki_native_i8(vflat, fsrc, 0);
+      case CA_UINT8: return cummax_ki_native_u8(vflat, fsrc, 0);
+      case CA_INT16: return cummax_ki_native_i16(vflat, fsrc, 0);
+      case CA_UINT16: return cummax_ki_native_u16(vflat, fsrc, 0);
+      case CA_INT32: return cummax_ki_native_i32(vflat, fsrc, 0);
+      case CA_UINT32: return cummax_ki_native_u32(vflat, fsrc, 0);
+      case CA_INT64: return cummax_ki_native_i64(vflat, fsrc, 0);
+      case CA_UINT64: return cummax_ki_native_u64(vflat, fsrc, 0);
+      case CA_FLOAT32: return cummax_ki_native_f32(vflat, fsrc, 0);
+      case CA_FLOAT64: return cummax_ki_native_f64(vflat, fsrc, 0);
+      case CA_BOOLEAN: return cummax_ki_native_bool(vflat, fsrc, 0);
+      case CA_OBJECT: return cummax_ki_native_object(vflat, fsrc, 0);
+      default:
+        rb_raise(rb_eCADataTypeError, "cummax_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, bool, object)", ca_type_name[fsrc->data_type]);
+    }
+  }
+  if ( TYPE(raxis) == T_ARRAY ) {
+    rb_raise(rb_eArgError, "cummax_ki: axis: must be Integer (got Array); multi-axis scan is semantically ambiguous, chain explicitly: a.cummax(axis: 0).cummax(axis: 1)");
+  }
+  if ( ! rb_obj_is_kind_of(raxis, rb_cInteger) ) {
+    rb_raise(rb_eTypeError, "cummax_ki: axis: must be Integer (got %"PRIsVALUE")", rb_obj_class(raxis));
+  }
+  int axis = NUM2INT(raxis);
+  if ( axis < 0 ) axis += src->ndim;
+  if ( axis < 0 || axis >= src->ndim ) {
+    rb_raise(rb_eArgError, "cummax_ki: axis %d out of range for ndim %d", NUM2INT(raxis), src->ndim);
+  }
+  switch ( src->data_type ) {
+    case CA_INT8: return cummax_ki_native_i8(self, src, axis);
+    case CA_UINT8: return cummax_ki_native_u8(self, src, axis);
+    case CA_INT16: return cummax_ki_native_i16(self, src, axis);
+    case CA_UINT16: return cummax_ki_native_u16(self, src, axis);
+    case CA_INT32: return cummax_ki_native_i32(self, src, axis);
+    case CA_UINT32: return cummax_ki_native_u32(self, src, axis);
+    case CA_INT64: return cummax_ki_native_i64(self, src, axis);
+    case CA_UINT64: return cummax_ki_native_u64(self, src, axis);
+    case CA_FLOAT32: return cummax_ki_native_f32(self, src, axis);
+    case CA_FLOAT64: return cummax_ki_native_f64(self, src, axis);
+    case CA_BOOLEAN: return cummax_ki_native_bool(self, src, axis);
+    case CA_OBJECT: return cummax_ki_native_object(self, src, axis);
+    default:
+      rb_raise(rb_eCADataTypeError, "cummax_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, bool, object)", 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,
+             "cummin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummin_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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,
+             "cummin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummin_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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,
+             "cummin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummin_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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,
+             "cummin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummin_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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,
+             "cummin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummin_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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,
+             "cummin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummin_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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,
+             "cummin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummin_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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,
+             "cummin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummin_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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,
+             "cummin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummin_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(float, float, st_in, pi, mi,
+                         st_out, po, mo_fiber, INFINITY, 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_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,
+             "cummin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummin_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (ca_size_t) co->bytes
+            : NULL;
+          CA_SLAB_SCAN_T_GATED(double, double, st_in, pi, mi,
+                         st_out, po, mo_fiber, INFINITY, 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_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,
+             "cummin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummin_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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;
+}
+
+static VALUE
+cummin_ki_native_object (VALUE self, CArray *ca, int axis)
+{
+  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;
+  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,
+             "cummin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cummin_ki: output init failed rc=%d", rc);
+  }
+
+    boolean8_t *op_mask = NULL;
+    char       *co_root = (char *) co->ptr;
+    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 - co_root) / (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) acc = v; else if (RTEST(rb_funcall(v, rb_intern("<"), 1, 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
+rb_ca_cummin_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  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, "cummin_ki: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cummin(axis: 0)", 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: return cummin_ki_native_i8(vflat, fsrc, 0);
+      case CA_UINT8: return cummin_ki_native_u8(vflat, fsrc, 0);
+      case CA_INT16: return cummin_ki_native_i16(vflat, fsrc, 0);
+      case CA_UINT16: return cummin_ki_native_u16(vflat, fsrc, 0);
+      case CA_INT32: return cummin_ki_native_i32(vflat, fsrc, 0);
+      case CA_UINT32: return cummin_ki_native_u32(vflat, fsrc, 0);
+      case CA_INT64: return cummin_ki_native_i64(vflat, fsrc, 0);
+      case CA_UINT64: return cummin_ki_native_u64(vflat, fsrc, 0);
+      case CA_FLOAT32: return cummin_ki_native_f32(vflat, fsrc, 0);
+      case CA_FLOAT64: return cummin_ki_native_f64(vflat, fsrc, 0);
+      case CA_BOOLEAN: return cummin_ki_native_bool(vflat, fsrc, 0);
+      case CA_OBJECT: return cummin_ki_native_object(vflat, fsrc, 0);
+      default:
+        rb_raise(rb_eCADataTypeError, "cummin_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, bool, object)", ca_type_name[fsrc->data_type]);
+    }
+  }
+  if ( TYPE(raxis) == T_ARRAY ) {
+    rb_raise(rb_eArgError, "cummin_ki: axis: must be Integer (got Array); multi-axis scan is semantically ambiguous, chain explicitly: a.cummin(axis: 0).cummin(axis: 1)");
+  }
+  if ( ! rb_obj_is_kind_of(raxis, rb_cInteger) ) {
+    rb_raise(rb_eTypeError, "cummin_ki: axis: must be Integer (got %"PRIsVALUE")", rb_obj_class(raxis));
+  }
+  int axis = NUM2INT(raxis);
+  if ( axis < 0 ) axis += src->ndim;
+  if ( axis < 0 || axis >= src->ndim ) {
+    rb_raise(rb_eArgError, "cummin_ki: axis %d out of range for ndim %d", NUM2INT(raxis), src->ndim);
+  }
+  switch ( src->data_type ) {
+    case CA_INT8: return cummin_ki_native_i8(self, src, axis);
+    case CA_UINT8: return cummin_ki_native_u8(self, src, axis);
+    case CA_INT16: return cummin_ki_native_i16(self, src, axis);
+    case CA_UINT16: return cummin_ki_native_u16(self, src, axis);
+    case CA_INT32: return cummin_ki_native_i32(self, src, axis);
+    case CA_UINT32: return cummin_ki_native_u32(self, src, axis);
+    case CA_INT64: return cummin_ki_native_i64(self, src, axis);
+    case CA_UINT64: return cummin_ki_native_u64(self, src, axis);
+    case CA_FLOAT32: return cummin_ki_native_f32(self, src, axis);
+    case CA_FLOAT64: return cummin_ki_native_f64(self, src, axis);
+    case CA_BOOLEAN: return cummin_ki_native_bool(self, src, axis);
+    case CA_OBJECT: return cummin_ki_native_object(self, src, axis);
+    default:
+      rb_raise(rb_eCADataTypeError, "cummin_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, bool, object)", 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,
+             "cumcount_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumcount_ki: output init failed rc=%d", 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,
+             "cumcount_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumcount_ki: output init failed rc=%d", 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,
+             "cumcount_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumcount_ki: output init failed rc=%d", 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,
+             "cumcount_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumcount_ki: output init failed rc=%d", 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,
+             "cumcount_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumcount_ki: output init failed rc=%d", 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,
+             "cumcount_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumcount_ki: output init failed rc=%d", 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,
+             "cumcount_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumcount_ki: output init failed rc=%d", 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,
+             "cumcount_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumcount_ki: output init failed rc=%d", 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,
+             "cumcount_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumcount_ki: output init failed rc=%d", 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,
+             "cumcount_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "cumcount_ki: output init failed rc=%d", 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);
+  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, "cumcount_ki: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cumcount(axis: 0)", 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: return cumcount_ki_native_i8(vflat, fsrc, 0);
+      case CA_UINT8: return cumcount_ki_native_u8(vflat, fsrc, 0);
+      case CA_INT16: return cumcount_ki_native_i16(vflat, fsrc, 0);
+      case CA_UINT16: return cumcount_ki_native_u16(vflat, fsrc, 0);
+      case CA_INT32: return cumcount_ki_native_i32(vflat, fsrc, 0);
+      case CA_UINT32: return cumcount_ki_native_u32(vflat, fsrc, 0);
+      case CA_INT64: return cumcount_ki_native_i64(vflat, fsrc, 0);
+      case CA_UINT64: return cumcount_ki_native_u64(vflat, fsrc, 0);
+      case CA_FLOAT32: return cumcount_ki_native_f32(vflat, fsrc, 0);
+      case CA_FLOAT64: return cumcount_ki_native_f64(vflat, fsrc, 0);
+      default: {
+        VALUE   vsrc = rb_ca_wrap_readonly(vflat, INT2NUM(CA_FLOAT64));
+        CArray *casted;
+        GetCArray(vsrc, casted);
+        return cumcount_ki_native_f64(vsrc, casted, 0);
+      }
+    }
+  }
+  if ( TYPE(raxis) == T_ARRAY ) {
+    rb_raise(rb_eArgError, "cumcount_ki: axis: must be Integer (got Array); multi-axis scan is semantically ambiguous, chain explicitly: a.cumcount(axis: 0).cumcount(axis: 1)");
+  }
+  if ( ! rb_obj_is_kind_of(raxis, rb_cInteger) ) {
+    rb_raise(rb_eTypeError, "cumcount_ki: axis: must be Integer (got %"PRIsVALUE")", rb_obj_class(raxis));
+  }
+  int axis = NUM2INT(raxis);
+  if ( axis < 0 ) axis += src->ndim;
+  if ( axis < 0 || axis >= src->ndim ) {
+    rb_raise(rb_eArgError, "cumcount_ki: axis %d out of range for ndim %d", NUM2INT(raxis), src->ndim);
+  }
+  switch ( src->data_type ) {
+    case CA_INT8: return cumcount_ki_native_i8(self, src, axis);
+    case CA_UINT8: return cumcount_ki_native_u8(self, src, axis);
+    case CA_INT16: return cumcount_ki_native_i16(self, src, axis);
+    case CA_UINT16: return cumcount_ki_native_u16(self, src, axis);
+    case CA_INT32: return cumcount_ki_native_i32(self, src, axis);
+    case CA_UINT32: return cumcount_ki_native_u32(self, src, axis);
+    case CA_INT64: return cumcount_ki_native_i64(self, src, axis);
+    case CA_UINT64: return cumcount_ki_native_u64(self, src, axis);
+    case CA_FLOAT32: return cumcount_ki_native_f32(self, src, axis);
+    case CA_FLOAT64: return cumcount_ki_native_f64(self, src, axis);
+    default: {
+      VALUE   vsrc = rb_ca_wrap_readonly(self, INT2NUM(CA_FLOAT64));
+      CArray *casted;
+      GetCArray(vsrc, casted);
+      return cumcount_ki_native_f64(vsrc, casted, 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,
+             "uniq_scan_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "uniq_scan_ki: output init failed rc=%d", 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,
+             "uniq_scan_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "uniq_scan_ki: output init failed rc=%d", 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,
+             "uniq_scan_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "uniq_scan_ki: output init failed rc=%d", 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,
+             "uniq_scan_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "uniq_scan_ki: output init failed rc=%d", 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,
+             "uniq_scan_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "uniq_scan_ki: output init failed rc=%d", 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,
+             "uniq_scan_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "uniq_scan_ki: output init failed rc=%d", 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,
+             "uniq_scan_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "uniq_scan_ki: output init failed rc=%d", 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,
+             "uniq_scan_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "uniq_scan_ki: output init failed rc=%d", 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,
+             "uniq_scan_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "uniq_scan_ki: output init failed rc=%d", 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,
+             "uniq_scan_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, 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,
+             "uniq_scan_ki: output init failed rc=%d", 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);
+  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, "uniq_scan_ki: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.uniq_scan(axis: 0)", argc);
+  }
+  if ( NIL_P(raxis) ) {
+    rb_raise(rb_eArgError, "uniq_scan_ki: axis: kwarg is required (single axis Integer; multi-axis scan is semantically ambiguous)");
+  }
+  if ( TYPE(raxis) == T_ARRAY ) {
+    rb_raise(rb_eArgError, "uniq_scan_ki: axis: must be Integer (got Array); multi-axis scan is semantically ambiguous, chain explicitly: a.uniq_scan(axis: 0).uniq_scan(axis: 1)");
+  }
+  if ( ! rb_obj_is_kind_of(raxis, rb_cInteger) ) {
+    rb_raise(rb_eTypeError, "uniq_scan_ki: axis: must be Integer (got %"PRIsVALUE")", rb_obj_class(raxis));
+  }
+  int axis = NUM2INT(raxis);
+  if ( axis < 0 ) axis += src->ndim;
+  if ( axis < 0 || axis >= src->ndim ) {
+    rb_raise(rb_eArgError, "uniq_scan_ki: axis %d out of range for ndim %d", NUM2INT(raxis), src->ndim);
+  }
+  switch ( src->data_type ) {
+    case CA_INT8: return uniq_scan_ki_native_i8(self, src, axis);
+    case CA_UINT8: return uniq_scan_ki_native_u8(self, src, axis);
+    case CA_INT16: return uniq_scan_ki_native_i16(self, src, axis);
+    case CA_UINT16: return uniq_scan_ki_native_u16(self, src, axis);
+    case CA_INT32: return uniq_scan_ki_native_i32(self, src, axis);
+    case CA_UINT32: return uniq_scan_ki_native_u32(self, src, axis);
+    case CA_INT64: return uniq_scan_ki_native_i64(self, src, axis);
+    case CA_UINT64: return uniq_scan_ki_native_u64(self, src, axis);
+    case CA_FLOAT32: return uniq_scan_ki_native_f32(self, src, axis);
+    case CA_FLOAT64: return uniq_scan_ki_native_f64(self, src, axis);
+    default:
+      rb_raise(rb_eCADataTypeError, "uniq_scan_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64)", 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_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);
+}