carray 3.0.4 → 3.0.5

data/ext/carray_kernels_reduce_cumulative.c

@@ -1167,18 +1167,18 @@ accumulate_ki_stream_i16 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(int16_t);
+      ca_size_t __s = sizeof(ca_u_int16_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      int16_t acc;
+      ca_u_int16_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      int16_t *__chunk = (int16_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(int16_t));
+      ca_u_int16_t *__chunk = (ca_u_int16_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_int16_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -1188,12 +1188,12 @@ accumulate_ki_stream_i16 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          int16_t v = __chunk[__i];
+          ca_u_int16_t v = __chunk[__i];
           acc += v;
         }
         __outer_off += __r;
       }
-      return LL2NUM((int16_t) (acc));
+      return LL2NUM((ca_u_int16_t) (acc));
 }
 
 static VALUE
@@ -1237,36 +1237,36 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT16, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int16_t *op = (int16_t *) co->ptr;
+        ca_u_int16_t *op = (ca_u_int16_t *) co->ptr;
         ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
-        const int16_t *p_root = (const int16_t *) ca->ptr;
+        const ca_u_int16_t *p_root = (const ca_u_int16_t *) ca->ptr;
 
         /* Per-buffer stack accumulators (one per :plus state, sized
            to L7 TILE = 512 cells regardless of INNER). */
-          int16_t  __li_buf_acc[512];
+          ca_u_int16_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const int16_t *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_int16_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int16_t) (0);
+                __li_buf_acc[__j] = (ca_u_int16_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const int16_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_int16_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                int16_t v = __li_row[__j];
+                ca_u_int16_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              op[__li_o * __li_INNER + __li_tile + __j] = (int16_t) (__li_buf_acc[__j]);
+              op[__li_o * __li_INNER + __li_tile + __j] = (ca_u_int16_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -1317,37 +1317,37 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT16, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int16_t *op = (int16_t *) co->ptr;
+        ca_u_int16_t *op = (ca_u_int16_t *) co->ptr;
 
-          int16_t  __li_buf_acc[512];
+          ca_u_int16_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const int16_t *p_root = (const int16_t *) __li_st->parents[__kk]->ptr;
-          int16_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
+          const ca_u_int16_t *p_root = (const ca_u_int16_t *) __li_st->parents[__kk]->ptr;
+          ca_u_int16_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const int16_t *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_int16_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int16_t) (0);
+                __li_buf_acc[__j] = (ca_u_int16_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const int16_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_int16_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                int16_t v = __li_row[__j];
+                ca_u_int16_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (int16_t) (__li_buf_acc[__j]);
+              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (ca_u_int16_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -1408,7 +1408,7 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT16, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int16_t *op = (int16_t *) co->ptr;
+        ca_u_int16_t *op = (ca_u_int16_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1).
            Output position vo maps to view position vv = (vo < ax) ? vo : vo + 1. */
@@ -1437,13 +1437,13 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
           __li_pre_dim[__pd] = __li_p0->dim[__pd];
         }
 
-          int16_t  __li_buf_acc[512];
+          ca_u_int16_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const int16_t *p_root = (const int16_t *) __li_st->parents[__kk]->ptr;
+          const ca_u_int16_t *p_root = (const ca_u_int16_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -1454,27 +1454,27 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
             for ( int8_t __pd = 0; __pd < __li_pa; __pd++ ) {
               __li_obase += __li_idx[__pd] * __li_pre_out_stride[__pd];
             }
-            int16_t *__li_op_k = op + __li_obase;
-            const int16_t *__li_plane = p_root + __li_o * __li_plane_elems;
+            ca_u_int16_t *__li_op_k = op + __li_obase;
+            const ca_u_int16_t *__li_plane = p_root + __li_o * __li_plane_elems;
             /* Inline single-OUTER core: j-stride 1 in __li_op_k preserved. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                         ? (__li_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int16_t) (0);
+                __li_buf_acc[__j] = (ca_u_int16_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const int16_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+                const ca_u_int16_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  int16_t v = __li_row[__j];
+                  ca_u_int16_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (int16_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_int16_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment OUTER multi-index (row-major over parent PRE dims). */
@@ -1555,7 +1555,7 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT16, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int16_t *op = (int16_t *) co->ptr;
+        ca_u_int16_t *op = (ca_u_int16_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1). */
         ca_size_t __li_out_stride[CA_RANK_MAX];
@@ -1598,12 +1598,12 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_OUTER = 1;
         for ( int8_t __k = 0; __k < __li_eo_n; __k++ ) __li_OUTER *= __li_eo_dim[__k];
 
-          int16_t  __li_buf_acc[512];
+          ca_u_int16_t  __li_buf_acc[512];
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const int16_t *p_root = (const int16_t *) __li_st->parents[__kk]->ptr;
+          const ca_u_int16_t *p_root = (const ca_u_int16_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -1616,27 +1616,27 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
               __li_pbase += __li_idx[__i] * __li_eo_pstride[__i];
               __li_obase += __li_idx[__i] * __li_eo_ostride[__i];
             }
-            int16_t *__li_op_k = op + __li_obase;
-            const int16_t *__li_plane = p_root + __li_pbase;
+            ca_u_int16_t *__li_op_k = op + __li_obase;
+            const ca_u_int16_t *__li_plane = p_root + __li_pbase;
             /* L.7 core variant: M-step uses __li_M_stride, tile loop uses __li_eff_INNER. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_eff_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_eff_INNER - __li_tile < __li_TILE)
                                         ? (__li_eff_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int16_t) (0);
+                __li_buf_acc[__j] = (ca_u_int16_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const int16_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
+                const ca_u_int16_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  int16_t v = __li_row[__j];
+                  ca_u_int16_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (int16_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_int16_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment effective OUTER multi-index. */
@@ -1655,7 +1655,7 @@ accumulate_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT16, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-int16_t *op = (int16_t *) co->ptr;
+ca_u_int16_t *op = (ca_u_int16_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -1668,10 +1668,10 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      int16_t acc;
+      ca_u_int16_t acc;
       ca_size_t masked_cnt = 0;
-#define __accumulate_i16_EXPR(__x) ((int16_t)(__x))
-      CA_SLAB_REDUCE_SUM8_EX(int16_t, int16_t, st, p, m, acc, 0, __accumulate_i16_EXPR, masked_cnt);
+#define __accumulate_i16_EXPR(__x) ((ca_u_int16_t)(__x))
+      CA_SLAB_REDUCE_SUM8_EX(ca_u_int16_t, ca_u_int16_t, st, p, m, acc, 0, __accumulate_i16_EXPR, masked_cnt);
 #undef __accumulate_i16_EXPR
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
@@ -1679,9 +1679,9 @@ ca_size_t   out_i = 0;
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (int16_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_int16_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (int16_t) (acc);
+        op[out_i++] = (ca_u_int16_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -1716,18 +1716,18 @@ accumulate_ki_stream_u16 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(uint16_t);
+      ca_size_t __s = sizeof(ca_u_uint16_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      uint16_t acc;
+      ca_u_uint16_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      uint16_t *__chunk = (uint16_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(uint16_t));
+      ca_u_uint16_t *__chunk = (ca_u_uint16_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_uint16_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -1737,12 +1737,12 @@ accumulate_ki_stream_u16 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          uint16_t v = __chunk[__i];
+          ca_u_uint16_t v = __chunk[__i];
           acc += v;
         }
         __outer_off += __r;
       }
-      return ULL2NUM((uint16_t) (acc));
+      return ULL2NUM((ca_u_uint16_t) (acc));
 }
 
 static VALUE
@@ -1786,36 +1786,36 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT16, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        uint16_t *op = (uint16_t *) co->ptr;
+        ca_u_uint16_t *op = (ca_u_uint16_t *) co->ptr;
         ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
-        const uint16_t *p_root = (const uint16_t *) ca->ptr;
+        const ca_u_uint16_t *p_root = (const ca_u_uint16_t *) ca->ptr;
 
         /* Per-buffer stack accumulators (one per :plus state, sized
            to L7 TILE = 512 cells regardless of INNER). */
-          uint16_t  __li_buf_acc[512];
+          ca_u_uint16_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const uint16_t *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_uint16_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (uint16_t) (0);
+                __li_buf_acc[__j] = (ca_u_uint16_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const uint16_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_uint16_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                uint16_t v = __li_row[__j];
+                ca_u_uint16_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              op[__li_o * __li_INNER + __li_tile + __j] = (uint16_t) (__li_buf_acc[__j]);
+              op[__li_o * __li_INNER + __li_tile + __j] = (ca_u_uint16_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -1866,37 +1866,37 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT16, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        uint16_t *op = (uint16_t *) co->ptr;
+        ca_u_uint16_t *op = (ca_u_uint16_t *) co->ptr;
 
-          uint16_t  __li_buf_acc[512];
+          ca_u_uint16_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const uint16_t *p_root = (const uint16_t *) __li_st->parents[__kk]->ptr;
-          uint16_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
+          const ca_u_uint16_t *p_root = (const ca_u_uint16_t *) __li_st->parents[__kk]->ptr;
+          ca_u_uint16_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const uint16_t *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_uint16_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (uint16_t) (0);
+                __li_buf_acc[__j] = (ca_u_uint16_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const uint16_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_uint16_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                uint16_t v = __li_row[__j];
+                ca_u_uint16_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (uint16_t) (__li_buf_acc[__j]);
+              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (ca_u_uint16_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -1957,7 +1957,7 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT16, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        uint16_t *op = (uint16_t *) co->ptr;
+        ca_u_uint16_t *op = (ca_u_uint16_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1).
            Output position vo maps to view position vv = (vo < ax) ? vo : vo + 1. */
@@ -1986,13 +1986,13 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
           __li_pre_dim[__pd] = __li_p0->dim[__pd];
         }
 
-          uint16_t  __li_buf_acc[512];
+          ca_u_uint16_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const uint16_t *p_root = (const uint16_t *) __li_st->parents[__kk]->ptr;
+          const ca_u_uint16_t *p_root = (const ca_u_uint16_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -2003,27 +2003,27 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
             for ( int8_t __pd = 0; __pd < __li_pa; __pd++ ) {
               __li_obase += __li_idx[__pd] * __li_pre_out_stride[__pd];
             }
-            uint16_t *__li_op_k = op + __li_obase;
-            const uint16_t *__li_plane = p_root + __li_o * __li_plane_elems;
+            ca_u_uint16_t *__li_op_k = op + __li_obase;
+            const ca_u_uint16_t *__li_plane = p_root + __li_o * __li_plane_elems;
             /* Inline single-OUTER core: j-stride 1 in __li_op_k preserved. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                         ? (__li_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (uint16_t) (0);
+                __li_buf_acc[__j] = (ca_u_uint16_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const uint16_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+                const ca_u_uint16_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  uint16_t v = __li_row[__j];
+                  ca_u_uint16_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (uint16_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_uint16_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment OUTER multi-index (row-major over parent PRE dims). */
@@ -2104,7 +2104,7 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT16, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        uint16_t *op = (uint16_t *) co->ptr;
+        ca_u_uint16_t *op = (ca_u_uint16_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1). */
         ca_size_t __li_out_stride[CA_RANK_MAX];
@@ -2147,12 +2147,12 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_OUTER = 1;
         for ( int8_t __k = 0; __k < __li_eo_n; __k++ ) __li_OUTER *= __li_eo_dim[__k];
 
-          uint16_t  __li_buf_acc[512];
+          ca_u_uint16_t  __li_buf_acc[512];
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const uint16_t *p_root = (const uint16_t *) __li_st->parents[__kk]->ptr;
+          const ca_u_uint16_t *p_root = (const ca_u_uint16_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -2165,27 +2165,27 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
               __li_pbase += __li_idx[__i] * __li_eo_pstride[__i];
               __li_obase += __li_idx[__i] * __li_eo_ostride[__i];
             }
-            uint16_t *__li_op_k = op + __li_obase;
-            const uint16_t *__li_plane = p_root + __li_pbase;
+            ca_u_uint16_t *__li_op_k = op + __li_obase;
+            const ca_u_uint16_t *__li_plane = p_root + __li_pbase;
             /* L.7 core variant: M-step uses __li_M_stride, tile loop uses __li_eff_INNER. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_eff_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_eff_INNER - __li_tile < __li_TILE)
                                         ? (__li_eff_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (uint16_t) (0);
+                __li_buf_acc[__j] = (ca_u_uint16_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const uint16_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
+                const ca_u_uint16_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  uint16_t v = __li_row[__j];
+                  ca_u_uint16_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (uint16_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_uint16_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment effective OUTER multi-index. */
@@ -2204,7 +2204,7 @@ accumulate_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT16, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-uint16_t *op = (uint16_t *) co->ptr;
+ca_u_uint16_t *op = (ca_u_uint16_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -2217,10 +2217,10 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      uint16_t acc;
+      ca_u_uint16_t acc;
       ca_size_t masked_cnt = 0;
-#define __accumulate_u16_EXPR(__x) ((uint16_t)(__x))
-      CA_SLAB_REDUCE_SUM8_EX(uint16_t, uint16_t, st, p, m, acc, 0, __accumulate_u16_EXPR, masked_cnt);
+#define __accumulate_u16_EXPR(__x) ((ca_u_uint16_t)(__x))
+      CA_SLAB_REDUCE_SUM8_EX(ca_u_uint16_t, ca_u_uint16_t, st, p, m, acc, 0, __accumulate_u16_EXPR, masked_cnt);
 #undef __accumulate_u16_EXPR
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
@@ -2228,9 +2228,9 @@ ca_size_t   out_i = 0;
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (uint16_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_uint16_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (uint16_t) (acc);
+        op[out_i++] = (ca_u_uint16_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -2265,18 +2265,18 @@ accumulate_ki_stream_i32 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(int32_t);
+      ca_size_t __s = sizeof(ca_u_int32_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      int32_t acc;
+      ca_u_int32_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      int32_t *__chunk = (int32_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(int32_t));
+      ca_u_int32_t *__chunk = (ca_u_int32_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_int32_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -2286,12 +2286,12 @@ accumulate_ki_stream_i32 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          int32_t v = __chunk[__i];
+          ca_u_int32_t v = __chunk[__i];
           acc += v;
         }
         __outer_off += __r;
       }
-      return LL2NUM((int32_t) (acc));
+      return LL2NUM((ca_u_int32_t) (acc));
 }
 
 static VALUE
@@ -2335,36 +2335,36 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT32, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int32_t *op = (int32_t *) co->ptr;
+        ca_u_int32_t *op = (ca_u_int32_t *) co->ptr;
         ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
-        const int32_t *p_root = (const int32_t *) ca->ptr;
+        const ca_u_int32_t *p_root = (const ca_u_int32_t *) ca->ptr;
 
         /* Per-buffer stack accumulators (one per :plus state, sized
            to L7 TILE = 512 cells regardless of INNER). */
-          int32_t  __li_buf_acc[512];
+          ca_u_int32_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const int32_t *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_int32_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int32_t) (0);
+                __li_buf_acc[__j] = (ca_u_int32_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const int32_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_int32_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                int32_t v = __li_row[__j];
+                ca_u_int32_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              op[__li_o * __li_INNER + __li_tile + __j] = (int32_t) (__li_buf_acc[__j]);
+              op[__li_o * __li_INNER + __li_tile + __j] = (ca_u_int32_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -2415,37 +2415,37 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT32, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int32_t *op = (int32_t *) co->ptr;
+        ca_u_int32_t *op = (ca_u_int32_t *) co->ptr;
 
-          int32_t  __li_buf_acc[512];
+          ca_u_int32_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const int32_t *p_root = (const int32_t *) __li_st->parents[__kk]->ptr;
-          int32_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
+          const ca_u_int32_t *p_root = (const ca_u_int32_t *) __li_st->parents[__kk]->ptr;
+          ca_u_int32_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const int32_t *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_int32_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int32_t) (0);
+                __li_buf_acc[__j] = (ca_u_int32_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const int32_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_int32_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                int32_t v = __li_row[__j];
+                ca_u_int32_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (int32_t) (__li_buf_acc[__j]);
+              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (ca_u_int32_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -2506,7 +2506,7 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT32, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int32_t *op = (int32_t *) co->ptr;
+        ca_u_int32_t *op = (ca_u_int32_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1).
            Output position vo maps to view position vv = (vo < ax) ? vo : vo + 1. */
@@ -2535,13 +2535,13 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
           __li_pre_dim[__pd] = __li_p0->dim[__pd];
         }
 
-          int32_t  __li_buf_acc[512];
+          ca_u_int32_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const int32_t *p_root = (const int32_t *) __li_st->parents[__kk]->ptr;
+          const ca_u_int32_t *p_root = (const ca_u_int32_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -2552,27 +2552,27 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
             for ( int8_t __pd = 0; __pd < __li_pa; __pd++ ) {
               __li_obase += __li_idx[__pd] * __li_pre_out_stride[__pd];
             }
-            int32_t *__li_op_k = op + __li_obase;
-            const int32_t *__li_plane = p_root + __li_o * __li_plane_elems;
+            ca_u_int32_t *__li_op_k = op + __li_obase;
+            const ca_u_int32_t *__li_plane = p_root + __li_o * __li_plane_elems;
             /* Inline single-OUTER core: j-stride 1 in __li_op_k preserved. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                         ? (__li_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int32_t) (0);
+                __li_buf_acc[__j] = (ca_u_int32_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const int32_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+                const ca_u_int32_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  int32_t v = __li_row[__j];
+                  ca_u_int32_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (int32_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_int32_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment OUTER multi-index (row-major over parent PRE dims). */
@@ -2653,7 +2653,7 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT32, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int32_t *op = (int32_t *) co->ptr;
+        ca_u_int32_t *op = (ca_u_int32_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1). */
         ca_size_t __li_out_stride[CA_RANK_MAX];
@@ -2696,12 +2696,12 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_OUTER = 1;
         for ( int8_t __k = 0; __k < __li_eo_n; __k++ ) __li_OUTER *= __li_eo_dim[__k];
 
-          int32_t  __li_buf_acc[512];
+          ca_u_int32_t  __li_buf_acc[512];
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const int32_t *p_root = (const int32_t *) __li_st->parents[__kk]->ptr;
+          const ca_u_int32_t *p_root = (const ca_u_int32_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -2714,27 +2714,27 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
               __li_pbase += __li_idx[__i] * __li_eo_pstride[__i];
               __li_obase += __li_idx[__i] * __li_eo_ostride[__i];
             }
-            int32_t *__li_op_k = op + __li_obase;
-            const int32_t *__li_plane = p_root + __li_pbase;
+            ca_u_int32_t *__li_op_k = op + __li_obase;
+            const ca_u_int32_t *__li_plane = p_root + __li_pbase;
             /* L.7 core variant: M-step uses __li_M_stride, tile loop uses __li_eff_INNER. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_eff_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_eff_INNER - __li_tile < __li_TILE)
                                         ? (__li_eff_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int32_t) (0);
+                __li_buf_acc[__j] = (ca_u_int32_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const int32_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
+                const ca_u_int32_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  int32_t v = __li_row[__j];
+                  ca_u_int32_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (int32_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_int32_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment effective OUTER multi-index. */
@@ -2753,7 +2753,7 @@ accumulate_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT32, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-int32_t *op = (int32_t *) co->ptr;
+ca_u_int32_t *op = (ca_u_int32_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -2766,10 +2766,10 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      int32_t acc;
+      ca_u_int32_t acc;
       ca_size_t masked_cnt = 0;
-#define __accumulate_i32_EXPR(__x) ((int32_t)(__x))
-      CA_SLAB_REDUCE_SUM8_EX(int32_t, int32_t, st, p, m, acc, 0, __accumulate_i32_EXPR, masked_cnt);
+#define __accumulate_i32_EXPR(__x) ((ca_u_int32_t)(__x))
+      CA_SLAB_REDUCE_SUM8_EX(ca_u_int32_t, ca_u_int32_t, st, p, m, acc, 0, __accumulate_i32_EXPR, masked_cnt);
 #undef __accumulate_i32_EXPR
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
@@ -2777,9 +2777,9 @@ ca_size_t   out_i = 0;
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (int32_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_int32_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (int32_t) (acc);
+        op[out_i++] = (ca_u_int32_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -2814,18 +2814,18 @@ accumulate_ki_stream_u32 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(uint32_t);
+      ca_size_t __s = sizeof(ca_u_uint32_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      uint32_t acc;
+      ca_u_uint32_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      uint32_t *__chunk = (uint32_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(uint32_t));
+      ca_u_uint32_t *__chunk = (ca_u_uint32_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_uint32_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -2835,12 +2835,12 @@ accumulate_ki_stream_u32 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          uint32_t v = __chunk[__i];
+          ca_u_uint32_t v = __chunk[__i];
           acc += v;
         }
         __outer_off += __r;
       }
-      return ULL2NUM((uint32_t) (acc));
+      return ULL2NUM((ca_u_uint32_t) (acc));
 }
 
 static VALUE
@@ -2884,36 +2884,36 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT32, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        uint32_t *op = (uint32_t *) co->ptr;
+        ca_u_uint32_t *op = (ca_u_uint32_t *) co->ptr;
         ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
-        const uint32_t *p_root = (const uint32_t *) ca->ptr;
+        const ca_u_uint32_t *p_root = (const ca_u_uint32_t *) ca->ptr;
 
         /* Per-buffer stack accumulators (one per :plus state, sized
            to L7 TILE = 512 cells regardless of INNER). */
-          uint32_t  __li_buf_acc[512];
+          ca_u_uint32_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const uint32_t *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_uint32_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (uint32_t) (0);
+                __li_buf_acc[__j] = (ca_u_uint32_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const uint32_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_uint32_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                uint32_t v = __li_row[__j];
+                ca_u_uint32_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              op[__li_o * __li_INNER + __li_tile + __j] = (uint32_t) (__li_buf_acc[__j]);
+              op[__li_o * __li_INNER + __li_tile + __j] = (ca_u_uint32_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -2964,37 +2964,37 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT32, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        uint32_t *op = (uint32_t *) co->ptr;
+        ca_u_uint32_t *op = (ca_u_uint32_t *) co->ptr;
 
-          uint32_t  __li_buf_acc[512];
+          ca_u_uint32_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const uint32_t *p_root = (const uint32_t *) __li_st->parents[__kk]->ptr;
-          uint32_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
+          const ca_u_uint32_t *p_root = (const ca_u_uint32_t *) __li_st->parents[__kk]->ptr;
+          ca_u_uint32_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const uint32_t *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_uint32_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (uint32_t) (0);
+                __li_buf_acc[__j] = (ca_u_uint32_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const uint32_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_uint32_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                uint32_t v = __li_row[__j];
+                ca_u_uint32_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (uint32_t) (__li_buf_acc[__j]);
+              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (ca_u_uint32_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -3055,7 +3055,7 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT32, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        uint32_t *op = (uint32_t *) co->ptr;
+        ca_u_uint32_t *op = (ca_u_uint32_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1).
            Output position vo maps to view position vv = (vo < ax) ? vo : vo + 1. */
@@ -3084,13 +3084,13 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
           __li_pre_dim[__pd] = __li_p0->dim[__pd];
         }
 
-          uint32_t  __li_buf_acc[512];
+          ca_u_uint32_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const uint32_t *p_root = (const uint32_t *) __li_st->parents[__kk]->ptr;
+          const ca_u_uint32_t *p_root = (const ca_u_uint32_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -3101,27 +3101,27 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
             for ( int8_t __pd = 0; __pd < __li_pa; __pd++ ) {
               __li_obase += __li_idx[__pd] * __li_pre_out_stride[__pd];
             }
-            uint32_t *__li_op_k = op + __li_obase;
-            const uint32_t *__li_plane = p_root + __li_o * __li_plane_elems;
+            ca_u_uint32_t *__li_op_k = op + __li_obase;
+            const ca_u_uint32_t *__li_plane = p_root + __li_o * __li_plane_elems;
             /* Inline single-OUTER core: j-stride 1 in __li_op_k preserved. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                         ? (__li_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (uint32_t) (0);
+                __li_buf_acc[__j] = (ca_u_uint32_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const uint32_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+                const ca_u_uint32_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  uint32_t v = __li_row[__j];
+                  ca_u_uint32_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (uint32_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_uint32_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment OUTER multi-index (row-major over parent PRE dims). */
@@ -3202,7 +3202,7 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT32, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        uint32_t *op = (uint32_t *) co->ptr;
+        ca_u_uint32_t *op = (ca_u_uint32_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1). */
         ca_size_t __li_out_stride[CA_RANK_MAX];
@@ -3245,12 +3245,12 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_OUTER = 1;
         for ( int8_t __k = 0; __k < __li_eo_n; __k++ ) __li_OUTER *= __li_eo_dim[__k];
 
-          uint32_t  __li_buf_acc[512];
+          ca_u_uint32_t  __li_buf_acc[512];
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const uint32_t *p_root = (const uint32_t *) __li_st->parents[__kk]->ptr;
+          const ca_u_uint32_t *p_root = (const ca_u_uint32_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -3263,27 +3263,27 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
               __li_pbase += __li_idx[__i] * __li_eo_pstride[__i];
               __li_obase += __li_idx[__i] * __li_eo_ostride[__i];
             }
-            uint32_t *__li_op_k = op + __li_obase;
-            const uint32_t *__li_plane = p_root + __li_pbase;
+            ca_u_uint32_t *__li_op_k = op + __li_obase;
+            const ca_u_uint32_t *__li_plane = p_root + __li_pbase;
             /* L.7 core variant: M-step uses __li_M_stride, tile loop uses __li_eff_INNER. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_eff_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_eff_INNER - __li_tile < __li_TILE)
                                         ? (__li_eff_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (uint32_t) (0);
+                __li_buf_acc[__j] = (ca_u_uint32_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const uint32_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
+                const ca_u_uint32_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  uint32_t v = __li_row[__j];
+                  ca_u_uint32_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (uint32_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_uint32_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment effective OUTER multi-index. */
@@ -3302,7 +3302,7 @@ accumulate_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT32, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-uint32_t *op = (uint32_t *) co->ptr;
+ca_u_uint32_t *op = (ca_u_uint32_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -3315,10 +3315,10 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      uint32_t acc;
+      ca_u_uint32_t acc;
       ca_size_t masked_cnt = 0;
-#define __accumulate_u32_EXPR(__x) ((uint32_t)(__x))
-      CA_SLAB_REDUCE_SUM8_EX(uint32_t, uint32_t, st, p, m, acc, 0, __accumulate_u32_EXPR, masked_cnt);
+#define __accumulate_u32_EXPR(__x) ((ca_u_uint32_t)(__x))
+      CA_SLAB_REDUCE_SUM8_EX(ca_u_uint32_t, ca_u_uint32_t, st, p, m, acc, 0, __accumulate_u32_EXPR, masked_cnt);
 #undef __accumulate_u32_EXPR
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
@@ -3326,9 +3326,9 @@ ca_size_t   out_i = 0;
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (uint32_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_uint32_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (uint32_t) (acc);
+        op[out_i++] = (ca_u_uint32_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -3363,18 +3363,18 @@ accumulate_ki_stream_i64 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(int64_t);
+      ca_size_t __s = sizeof(ca_u_int64_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      int64_t acc;
+      ca_u_int64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      int64_t *__chunk = (int64_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(int64_t));
+      ca_u_int64_t *__chunk = (ca_u_int64_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_int64_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -3384,12 +3384,12 @@ accumulate_ki_stream_i64 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          int64_t v = __chunk[__i];
+          ca_u_int64_t v = __chunk[__i];
           acc += v;
         }
         __outer_off += __r;
       }
-      return LL2NUM((int64_t) (acc));
+      return LL2NUM((ca_u_int64_t) (acc));
 }
 
 static VALUE
@@ -3433,36 +3433,36 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int64_t *op = (int64_t *) co->ptr;
+        ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
         ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
-        const int64_t *p_root = (const int64_t *) ca->ptr;
+        const ca_u_int64_t *p_root = (const ca_u_int64_t *) ca->ptr;
 
         /* Per-buffer stack accumulators (one per :plus state, sized
            to L7 TILE = 512 cells regardless of INNER). */
-          int64_t  __li_buf_acc[512];
+          ca_u_int64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const int64_t *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_int64_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int64_t) (0);
+                __li_buf_acc[__j] = (ca_u_int64_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const int64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_int64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                int64_t v = __li_row[__j];
+                ca_u_int64_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              op[__li_o * __li_INNER + __li_tile + __j] = (int64_t) (__li_buf_acc[__j]);
+              op[__li_o * __li_INNER + __li_tile + __j] = (ca_u_int64_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -3513,37 +3513,37 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int64_t *op = (int64_t *) co->ptr;
+        ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 
-          int64_t  __li_buf_acc[512];
+          ca_u_int64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const int64_t *p_root = (const int64_t *) __li_st->parents[__kk]->ptr;
-          int64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
+          const ca_u_int64_t *p_root = (const ca_u_int64_t *) __li_st->parents[__kk]->ptr;
+          ca_u_int64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const int64_t *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_int64_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int64_t) (0);
+                __li_buf_acc[__j] = (ca_u_int64_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const int64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_int64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                int64_t v = __li_row[__j];
+                ca_u_int64_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (int64_t) (__li_buf_acc[__j]);
+              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (ca_u_int64_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -3604,7 +3604,7 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int64_t *op = (int64_t *) co->ptr;
+        ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1).
            Output position vo maps to view position vv = (vo < ax) ? vo : vo + 1. */
@@ -3633,13 +3633,13 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
           __li_pre_dim[__pd] = __li_p0->dim[__pd];
         }
 
-          int64_t  __li_buf_acc[512];
+          ca_u_int64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const int64_t *p_root = (const int64_t *) __li_st->parents[__kk]->ptr;
+          const ca_u_int64_t *p_root = (const ca_u_int64_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -3650,27 +3650,27 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
             for ( int8_t __pd = 0; __pd < __li_pa; __pd++ ) {
               __li_obase += __li_idx[__pd] * __li_pre_out_stride[__pd];
             }
-            int64_t *__li_op_k = op + __li_obase;
-            const int64_t *__li_plane = p_root + __li_o * __li_plane_elems;
+            ca_u_int64_t *__li_op_k = op + __li_obase;
+            const ca_u_int64_t *__li_plane = p_root + __li_o * __li_plane_elems;
             /* Inline single-OUTER core: j-stride 1 in __li_op_k preserved. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                         ? (__li_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int64_t) (0);
+                __li_buf_acc[__j] = (ca_u_int64_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const int64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+                const ca_u_int64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  int64_t v = __li_row[__j];
+                  ca_u_int64_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (int64_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_int64_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment OUTER multi-index (row-major over parent PRE dims). */
@@ -3751,7 +3751,7 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int64_t *op = (int64_t *) co->ptr;
+        ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1). */
         ca_size_t __li_out_stride[CA_RANK_MAX];
@@ -3794,12 +3794,12 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_OUTER = 1;
         for ( int8_t __k = 0; __k < __li_eo_n; __k++ ) __li_OUTER *= __li_eo_dim[__k];
 
-          int64_t  __li_buf_acc[512];
+          ca_u_int64_t  __li_buf_acc[512];
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const int64_t *p_root = (const int64_t *) __li_st->parents[__kk]->ptr;
+          const ca_u_int64_t *p_root = (const ca_u_int64_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -3812,27 +3812,27 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
               __li_pbase += __li_idx[__i] * __li_eo_pstride[__i];
               __li_obase += __li_idx[__i] * __li_eo_ostride[__i];
             }
-            int64_t *__li_op_k = op + __li_obase;
-            const int64_t *__li_plane = p_root + __li_pbase;
+            ca_u_int64_t *__li_op_k = op + __li_obase;
+            const ca_u_int64_t *__li_plane = p_root + __li_pbase;
             /* L.7 core variant: M-step uses __li_M_stride, tile loop uses __li_eff_INNER. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_eff_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_eff_INNER - __li_tile < __li_TILE)
                                         ? (__li_eff_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int64_t) (0);
+                __li_buf_acc[__j] = (ca_u_int64_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const int64_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
+                const ca_u_int64_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  int64_t v = __li_row[__j];
+                  ca_u_int64_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (int64_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_int64_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment effective OUTER multi-index. */
@@ -3851,7 +3851,7 @@ accumulate_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-int64_t *op = (int64_t *) co->ptr;
+ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -3864,10 +3864,10 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      int64_t acc;
+      ca_u_int64_t acc;
       ca_size_t masked_cnt = 0;
-#define __accumulate_i64_EXPR(__x) ((int64_t)(__x))
-      CA_SLAB_REDUCE_SUM8_EX(int64_t, int64_t, st, p, m, acc, 0, __accumulate_i64_EXPR, masked_cnt);
+#define __accumulate_i64_EXPR(__x) ((ca_u_int64_t)(__x))
+      CA_SLAB_REDUCE_SUM8_EX(ca_u_int64_t, ca_u_int64_t, st, p, m, acc, 0, __accumulate_i64_EXPR, masked_cnt);
 #undef __accumulate_i64_EXPR
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
@@ -3875,9 +3875,9 @@ ca_size_t   out_i = 0;
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (int64_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_int64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (int64_t) (acc);
+        op[out_i++] = (ca_u_int64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -3912,18 +3912,18 @@ accumulate_ki_stream_u64 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(uint64_t);
+      ca_size_t __s = sizeof(ca_u_uint64_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      uint64_t acc;
+      ca_u_uint64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      uint64_t *__chunk = (uint64_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(uint64_t));
+      ca_u_uint64_t *__chunk = (ca_u_uint64_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_uint64_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -3933,12 +3933,12 @@ accumulate_ki_stream_u64 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          uint64_t v = __chunk[__i];
+          ca_u_uint64_t v = __chunk[__i];
           acc += v;
         }
         __outer_off += __r;
       }
-      return ULL2NUM((uint64_t) (acc));
+      return ULL2NUM((ca_u_uint64_t) (acc));
 }
 
 static VALUE
@@ -3982,36 +3982,36 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        uint64_t *op = (uint64_t *) co->ptr;
+        ca_u_uint64_t *op = (ca_u_uint64_t *) co->ptr;
         ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
-        const uint64_t *p_root = (const uint64_t *) ca->ptr;
+        const ca_u_uint64_t *p_root = (const ca_u_uint64_t *) ca->ptr;
 
         /* Per-buffer stack accumulators (one per :plus state, sized
            to L7 TILE = 512 cells regardless of INNER). */
-          uint64_t  __li_buf_acc[512];
+          ca_u_uint64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const uint64_t *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_uint64_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (uint64_t) (0);
+                __li_buf_acc[__j] = (ca_u_uint64_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const uint64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_uint64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                uint64_t v = __li_row[__j];
+                ca_u_uint64_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              op[__li_o * __li_INNER + __li_tile + __j] = (uint64_t) (__li_buf_acc[__j]);
+              op[__li_o * __li_INNER + __li_tile + __j] = (ca_u_uint64_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -4062,37 +4062,37 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        uint64_t *op = (uint64_t *) co->ptr;
+        ca_u_uint64_t *op = (ca_u_uint64_t *) co->ptr;
 
-          uint64_t  __li_buf_acc[512];
+          ca_u_uint64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const uint64_t *p_root = (const uint64_t *) __li_st->parents[__kk]->ptr;
-          uint64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
+          const ca_u_uint64_t *p_root = (const ca_u_uint64_t *) __li_st->parents[__kk]->ptr;
+          ca_u_uint64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const uint64_t *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_uint64_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (uint64_t) (0);
+                __li_buf_acc[__j] = (ca_u_uint64_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const uint64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_uint64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                uint64_t v = __li_row[__j];
+                ca_u_uint64_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (uint64_t) (__li_buf_acc[__j]);
+              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (ca_u_uint64_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -4153,7 +4153,7 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        uint64_t *op = (uint64_t *) co->ptr;
+        ca_u_uint64_t *op = (ca_u_uint64_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1).
            Output position vo maps to view position vv = (vo < ax) ? vo : vo + 1. */
@@ -4182,13 +4182,13 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
           __li_pre_dim[__pd] = __li_p0->dim[__pd];
         }
 
-          uint64_t  __li_buf_acc[512];
+          ca_u_uint64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const uint64_t *p_root = (const uint64_t *) __li_st->parents[__kk]->ptr;
+          const ca_u_uint64_t *p_root = (const ca_u_uint64_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -4199,27 +4199,27 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
             for ( int8_t __pd = 0; __pd < __li_pa; __pd++ ) {
               __li_obase += __li_idx[__pd] * __li_pre_out_stride[__pd];
             }
-            uint64_t *__li_op_k = op + __li_obase;
-            const uint64_t *__li_plane = p_root + __li_o * __li_plane_elems;
+            ca_u_uint64_t *__li_op_k = op + __li_obase;
+            const ca_u_uint64_t *__li_plane = p_root + __li_o * __li_plane_elems;
             /* Inline single-OUTER core: j-stride 1 in __li_op_k preserved. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                         ? (__li_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (uint64_t) (0);
+                __li_buf_acc[__j] = (ca_u_uint64_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const uint64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+                const ca_u_uint64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  uint64_t v = __li_row[__j];
+                  ca_u_uint64_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (uint64_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_uint64_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment OUTER multi-index (row-major over parent PRE dims). */
@@ -4300,7 +4300,7 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        uint64_t *op = (uint64_t *) co->ptr;
+        ca_u_uint64_t *op = (ca_u_uint64_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1). */
         ca_size_t __li_out_stride[CA_RANK_MAX];
@@ -4343,12 +4343,12 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_OUTER = 1;
         for ( int8_t __k = 0; __k < __li_eo_n; __k++ ) __li_OUTER *= __li_eo_dim[__k];
 
-          uint64_t  __li_buf_acc[512];
+          ca_u_uint64_t  __li_buf_acc[512];
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const uint64_t *p_root = (const uint64_t *) __li_st->parents[__kk]->ptr;
+          const ca_u_uint64_t *p_root = (const ca_u_uint64_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -4361,27 +4361,27 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
               __li_pbase += __li_idx[__i] * __li_eo_pstride[__i];
               __li_obase += __li_idx[__i] * __li_eo_ostride[__i];
             }
-            uint64_t *__li_op_k = op + __li_obase;
-            const uint64_t *__li_plane = p_root + __li_pbase;
+            ca_u_uint64_t *__li_op_k = op + __li_obase;
+            const ca_u_uint64_t *__li_plane = p_root + __li_pbase;
             /* L.7 core variant: M-step uses __li_M_stride, tile loop uses __li_eff_INNER. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_eff_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_eff_INNER - __li_tile < __li_TILE)
                                         ? (__li_eff_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (uint64_t) (0);
+                __li_buf_acc[__j] = (ca_u_uint64_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const uint64_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
+                const ca_u_uint64_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  uint64_t v = __li_row[__j];
+                  ca_u_uint64_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (uint64_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_uint64_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment effective OUTER multi-index. */
@@ -4400,7 +4400,7 @@ accumulate_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_UINT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-uint64_t *op = (uint64_t *) co->ptr;
+ca_u_uint64_t *op = (ca_u_uint64_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -4413,10 +4413,10 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      uint64_t acc;
+      ca_u_uint64_t acc;
       ca_size_t masked_cnt = 0;
-#define __accumulate_u64_EXPR(__x) ((uint64_t)(__x))
-      CA_SLAB_REDUCE_SUM8_EX(uint64_t, uint64_t, st, p, m, acc, 0, __accumulate_u64_EXPR, masked_cnt);
+#define __accumulate_u64_EXPR(__x) ((ca_u_uint64_t)(__x))
+      CA_SLAB_REDUCE_SUM8_EX(ca_u_uint64_t, ca_u_uint64_t, st, p, m, acc, 0, __accumulate_u64_EXPR, masked_cnt);
 #undef __accumulate_u64_EXPR
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
@@ -4424,9 +4424,9 @@ ca_size_t   out_i = 0;
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (uint64_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_uint64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (uint64_t) (acc);
+        op[out_i++] = (ca_u_uint64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -4461,18 +4461,18 @@ accumulate_ki_stream_f32 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(float);
+      ca_size_t __s = sizeof(ca_u_float32_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      float acc;
+      ca_u_float32_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      float *__chunk = (float *) ca_lazy_arena_acquire(__chunk_elems * sizeof(float));
+      ca_u_float32_t *__chunk = (ca_u_float32_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_float32_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -4482,12 +4482,12 @@ accumulate_ki_stream_f32 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          float v = __chunk[__i];
+          ca_u_float32_t v = __chunk[__i];
           acc += v;
         }
         __outer_off += __r;
       }
-      return rb_float_new((float) (acc));
+      return rb_float_new((ca_u_float32_t) (acc));
 }
 
 static VALUE
@@ -4531,36 +4531,36 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT32, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        float *op = (float *) co->ptr;
+        ca_u_float32_t *op = (ca_u_float32_t *) co->ptr;
         ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
-        const float *p_root = (const float *) ca->ptr;
+        const ca_u_float32_t *p_root = (const ca_u_float32_t *) ca->ptr;
 
         /* Per-buffer stack accumulators (one per :plus state, sized
            to L7 TILE = 512 cells regardless of INNER). */
-          float  __li_buf_acc[512];
+          ca_u_float32_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const float *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_float32_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (float) (0);
+                __li_buf_acc[__j] = (ca_u_float32_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const float *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_float32_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                float v = __li_row[__j];
+                ca_u_float32_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              op[__li_o * __li_INNER + __li_tile + __j] = (float) (__li_buf_acc[__j]);
+              op[__li_o * __li_INNER + __li_tile + __j] = (ca_u_float32_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -4611,37 +4611,37 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT32, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        float *op = (float *) co->ptr;
+        ca_u_float32_t *op = (ca_u_float32_t *) co->ptr;
 
-          float  __li_buf_acc[512];
+          ca_u_float32_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const float *p_root = (const float *) __li_st->parents[__kk]->ptr;
-          float *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
+          const ca_u_float32_t *p_root = (const ca_u_float32_t *) __li_st->parents[__kk]->ptr;
+          ca_u_float32_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const float *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_float32_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (float) (0);
+                __li_buf_acc[__j] = (ca_u_float32_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const float *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_float32_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                float v = __li_row[__j];
+                ca_u_float32_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (float) (__li_buf_acc[__j]);
+              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (ca_u_float32_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -4702,7 +4702,7 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT32, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        float *op = (float *) co->ptr;
+        ca_u_float32_t *op = (ca_u_float32_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1).
            Output position vo maps to view position vv = (vo < ax) ? vo : vo + 1. */
@@ -4731,13 +4731,13 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
           __li_pre_dim[__pd] = __li_p0->dim[__pd];
         }
 
-          float  __li_buf_acc[512];
+          ca_u_float32_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const float *p_root = (const float *) __li_st->parents[__kk]->ptr;
+          const ca_u_float32_t *p_root = (const ca_u_float32_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -4748,27 +4748,27 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
             for ( int8_t __pd = 0; __pd < __li_pa; __pd++ ) {
               __li_obase += __li_idx[__pd] * __li_pre_out_stride[__pd];
             }
-            float *__li_op_k = op + __li_obase;
-            const float *__li_plane = p_root + __li_o * __li_plane_elems;
+            ca_u_float32_t *__li_op_k = op + __li_obase;
+            const ca_u_float32_t *__li_plane = p_root + __li_o * __li_plane_elems;
             /* Inline single-OUTER core: j-stride 1 in __li_op_k preserved. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                         ? (__li_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (float) (0);
+                __li_buf_acc[__j] = (ca_u_float32_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const float *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+                const ca_u_float32_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  float v = __li_row[__j];
+                  ca_u_float32_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (float) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_float32_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment OUTER multi-index (row-major over parent PRE dims). */
@@ -4849,7 +4849,7 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT32, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        float *op = (float *) co->ptr;
+        ca_u_float32_t *op = (ca_u_float32_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1). */
         ca_size_t __li_out_stride[CA_RANK_MAX];
@@ -4892,12 +4892,12 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_OUTER = 1;
         for ( int8_t __k = 0; __k < __li_eo_n; __k++ ) __li_OUTER *= __li_eo_dim[__k];
 
-          float  __li_buf_acc[512];
+          ca_u_float32_t  __li_buf_acc[512];
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const float *p_root = (const float *) __li_st->parents[__kk]->ptr;
+          const ca_u_float32_t *p_root = (const ca_u_float32_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -4910,27 +4910,27 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
               __li_pbase += __li_idx[__i] * __li_eo_pstride[__i];
               __li_obase += __li_idx[__i] * __li_eo_ostride[__i];
             }
-            float *__li_op_k = op + __li_obase;
-            const float *__li_plane = p_root + __li_pbase;
+            ca_u_float32_t *__li_op_k = op + __li_obase;
+            const ca_u_float32_t *__li_plane = p_root + __li_pbase;
             /* L.7 core variant: M-step uses __li_M_stride, tile loop uses __li_eff_INNER. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_eff_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_eff_INNER - __li_tile < __li_TILE)
                                         ? (__li_eff_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (float) (0);
+                __li_buf_acc[__j] = (ca_u_float32_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const float *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
+                const ca_u_float32_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  float v = __li_row[__j];
+                  ca_u_float32_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (float) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_float32_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment effective OUTER multi-index. */
@@ -4949,7 +4949,7 @@ accumulate_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT32, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-float *op = (float *) co->ptr;
+ca_u_float32_t *op = (ca_u_float32_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -4962,10 +4962,10 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      float acc;
+      ca_u_float32_t acc;
       ca_size_t masked_cnt = 0;
-#define __accumulate_f32_EXPR(__x) ((float)(__x))
-      CA_SLAB_REDUCE_SUM8_EX(float, float, st, p, m, acc, 0, __accumulate_f32_EXPR, masked_cnt);
+#define __accumulate_f32_EXPR(__x) ((ca_u_float32_t)(__x))
+      CA_SLAB_REDUCE_SUM8_EX(ca_u_float32_t, ca_u_float32_t, st, p, m, acc, 0, __accumulate_f32_EXPR, masked_cnt);
 #undef __accumulate_f32_EXPR
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
@@ -4973,9 +4973,9 @@ ca_size_t   out_i = 0;
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (float) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_float32_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (float) (acc);
+        op[out_i++] = (ca_u_float32_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -5010,18 +5010,18 @@ accumulate_ki_stream_f64 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(double);
+      ca_size_t __s = sizeof(ca_u_float64_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      double acc;
+      ca_u_float64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      double *__chunk = (double *) ca_lazy_arena_acquire(__chunk_elems * sizeof(double));
+      ca_u_float64_t *__chunk = (ca_u_float64_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_float64_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -5031,12 +5031,12 @@ accumulate_ki_stream_f64 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          double v = __chunk[__i];
+          ca_u_float64_t v = __chunk[__i];
           acc += v;
         }
         __outer_off += __r;
       }
-      return rb_float_new((double) (acc));
+      return rb_float_new((ca_u_float64_t) (acc));
 }
 
 static VALUE
@@ -5080,36 +5080,36 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        double *op = (double *) co->ptr;
+        ca_u_float64_t *op = (ca_u_float64_t *) co->ptr;
         ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
-        const double *p_root = (const double *) ca->ptr;
+        const ca_u_float64_t *p_root = (const ca_u_float64_t *) ca->ptr;
 
         /* Per-buffer stack accumulators (one per :plus state, sized
            to L7 TILE = 512 cells regardless of INNER). */
-          double  __li_buf_acc[512];
+          ca_u_float64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const double *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_float64_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (double) (0);
+                __li_buf_acc[__j] = (ca_u_float64_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const double *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_float64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                double v = __li_row[__j];
+                ca_u_float64_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              op[__li_o * __li_INNER + __li_tile + __j] = (double) (__li_buf_acc[__j]);
+              op[__li_o * __li_INNER + __li_tile + __j] = (ca_u_float64_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -5160,37 +5160,37 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        double *op = (double *) co->ptr;
+        ca_u_float64_t *op = (ca_u_float64_t *) co->ptr;
 
-          double  __li_buf_acc[512];
+          ca_u_float64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const double *p_root = (const double *) __li_st->parents[__kk]->ptr;
-          double *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
+          const ca_u_float64_t *p_root = (const ca_u_float64_t *) __li_st->parents[__kk]->ptr;
+          ca_u_float64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const double *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_float64_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (double) (0);
+                __li_buf_acc[__j] = (ca_u_float64_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const double *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_float64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                double v = __li_row[__j];
+                ca_u_float64_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (double) (__li_buf_acc[__j]);
+              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (ca_u_float64_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -5251,7 +5251,7 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        double *op = (double *) co->ptr;
+        ca_u_float64_t *op = (ca_u_float64_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1).
            Output position vo maps to view position vv = (vo < ax) ? vo : vo + 1. */
@@ -5280,13 +5280,13 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
           __li_pre_dim[__pd] = __li_p0->dim[__pd];
         }
 
-          double  __li_buf_acc[512];
+          ca_u_float64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const double *p_root = (const double *) __li_st->parents[__kk]->ptr;
+          const ca_u_float64_t *p_root = (const ca_u_float64_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -5297,27 +5297,27 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
             for ( int8_t __pd = 0; __pd < __li_pa; __pd++ ) {
               __li_obase += __li_idx[__pd] * __li_pre_out_stride[__pd];
             }
-            double *__li_op_k = op + __li_obase;
-            const double *__li_plane = p_root + __li_o * __li_plane_elems;
+            ca_u_float64_t *__li_op_k = op + __li_obase;
+            const ca_u_float64_t *__li_plane = p_root + __li_o * __li_plane_elems;
             /* Inline single-OUTER core: j-stride 1 in __li_op_k preserved. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                         ? (__li_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (double) (0);
+                __li_buf_acc[__j] = (ca_u_float64_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const double *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+                const ca_u_float64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  double v = __li_row[__j];
+                  ca_u_float64_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (double) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_float64_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment OUTER multi-index (row-major over parent PRE dims). */
@@ -5398,7 +5398,7 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        double *op = (double *) co->ptr;
+        ca_u_float64_t *op = (ca_u_float64_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1). */
         ca_size_t __li_out_stride[CA_RANK_MAX];
@@ -5441,12 +5441,12 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
         ca_size_t __li_OUTER = 1;
         for ( int8_t __k = 0; __k < __li_eo_n; __k++ ) __li_OUTER *= __li_eo_dim[__k];
 
-          double  __li_buf_acc[512];
+          ca_u_float64_t  __li_buf_acc[512];
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const double *p_root = (const double *) __li_st->parents[__kk]->ptr;
+          const ca_u_float64_t *p_root = (const ca_u_float64_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -5459,27 +5459,27 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
               __li_pbase += __li_idx[__i] * __li_eo_pstride[__i];
               __li_obase += __li_idx[__i] * __li_eo_ostride[__i];
             }
-            double *__li_op_k = op + __li_obase;
-            const double *__li_plane = p_root + __li_pbase;
+            ca_u_float64_t *__li_op_k = op + __li_obase;
+            const ca_u_float64_t *__li_plane = p_root + __li_pbase;
             /* L.7 core variant: M-step uses __li_M_stride, tile loop uses __li_eff_INNER. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_eff_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_eff_INNER - __li_tile < __li_TILE)
                                         ? (__li_eff_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (double) (0);
+                __li_buf_acc[__j] = (ca_u_float64_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const double *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
+                const ca_u_float64_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  double v = __li_row[__j];
+                  ca_u_float64_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (double) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_float64_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment effective OUTER multi-index. */
@@ -5498,7 +5498,7 @@ accumulate_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-double *op = (double *) co->ptr;
+ca_u_float64_t *op = (ca_u_float64_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -5511,10 +5511,10 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      double acc;
+      ca_u_float64_t acc;
       ca_size_t masked_cnt = 0;
-#define __accumulate_f64_EXPR(__x) ((double)(__x))
-      CA_SLAB_REDUCE_SUM8_EX(double, double, st, p, m, acc, 0, __accumulate_f64_EXPR, masked_cnt);
+#define __accumulate_f64_EXPR(__x) ((ca_u_float64_t)(__x))
+      CA_SLAB_REDUCE_SUM8_EX(ca_u_float64_t, ca_u_float64_t, st, p, m, acc, 0, __accumulate_f64_EXPR, masked_cnt);
 #undef __accumulate_f64_EXPR
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
@@ -5522,9 +5522,9 @@ ca_size_t   out_i = 0;
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (double) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_float64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (double) (acc);
+        op[out_i++] = (ca_u_float64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -5559,18 +5559,18 @@ accumulate_ki_stream_cmplx64 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(cmplx64_t);
+      ca_size_t __s = sizeof(ca_u_cmplx64_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      cmplx64_t acc;
+      ca_u_cmplx64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      cmplx64_t *__chunk = (cmplx64_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(cmplx64_t));
+      ca_u_cmplx64_t *__chunk = (ca_u_cmplx64_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_cmplx64_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -5580,12 +5580,12 @@ accumulate_ki_stream_cmplx64 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          cmplx64_t v = __chunk[__i];
+          ca_u_cmplx64_t v = __chunk[__i];
           acc += v;
         }
         __outer_off += __r;
       }
-      return CC2NUM((cmplx64_t) (acc));
+      return CC2NUM((ca_u_cmplx64_t) (acc));
 }
 
 static VALUE
@@ -5629,36 +5629,36 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_CMPLX64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        cmplx64_t *op = (cmplx64_t *) co->ptr;
+        ca_u_cmplx64_t *op = (ca_u_cmplx64_t *) co->ptr;
         ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
-        const cmplx64_t *p_root = (const cmplx64_t *) ca->ptr;
+        const ca_u_cmplx64_t *p_root = (const ca_u_cmplx64_t *) ca->ptr;
 
         /* Per-buffer stack accumulators (one per :plus state, sized
            to L7 TILE = 512 cells regardless of INNER). */
-          cmplx64_t  __li_buf_acc[512];
+          ca_u_cmplx64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const cmplx64_t *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_cmplx64_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (cmplx64_t) (0);
+                __li_buf_acc[__j] = (ca_u_cmplx64_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const cmplx64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_cmplx64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                cmplx64_t v = __li_row[__j];
+                ca_u_cmplx64_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              op[__li_o * __li_INNER + __li_tile + __j] = (cmplx64_t) (__li_buf_acc[__j]);
+              op[__li_o * __li_INNER + __li_tile + __j] = (ca_u_cmplx64_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -5709,37 +5709,37 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_CMPLX64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        cmplx64_t *op = (cmplx64_t *) co->ptr;
+        ca_u_cmplx64_t *op = (ca_u_cmplx64_t *) co->ptr;
 
-          cmplx64_t  __li_buf_acc[512];
+          ca_u_cmplx64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const cmplx64_t *p_root = (const cmplx64_t *) __li_st->parents[__kk]->ptr;
-          cmplx64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
+          const ca_u_cmplx64_t *p_root = (const ca_u_cmplx64_t *) __li_st->parents[__kk]->ptr;
+          ca_u_cmplx64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const cmplx64_t *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_cmplx64_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (cmplx64_t) (0);
+                __li_buf_acc[__j] = (ca_u_cmplx64_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const cmplx64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_cmplx64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                cmplx64_t v = __li_row[__j];
+                ca_u_cmplx64_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (cmplx64_t) (__li_buf_acc[__j]);
+              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (ca_u_cmplx64_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -5800,7 +5800,7 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_CMPLX64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        cmplx64_t *op = (cmplx64_t *) co->ptr;
+        ca_u_cmplx64_t *op = (ca_u_cmplx64_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1).
            Output position vo maps to view position vv = (vo < ax) ? vo : vo + 1. */
@@ -5829,13 +5829,13 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
           __li_pre_dim[__pd] = __li_p0->dim[__pd];
         }
 
-          cmplx64_t  __li_buf_acc[512];
+          ca_u_cmplx64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const cmplx64_t *p_root = (const cmplx64_t *) __li_st->parents[__kk]->ptr;
+          const ca_u_cmplx64_t *p_root = (const ca_u_cmplx64_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -5846,27 +5846,27 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
             for ( int8_t __pd = 0; __pd < __li_pa; __pd++ ) {
               __li_obase += __li_idx[__pd] * __li_pre_out_stride[__pd];
             }
-            cmplx64_t *__li_op_k = op + __li_obase;
-            const cmplx64_t *__li_plane = p_root + __li_o * __li_plane_elems;
+            ca_u_cmplx64_t *__li_op_k = op + __li_obase;
+            const ca_u_cmplx64_t *__li_plane = p_root + __li_o * __li_plane_elems;
             /* Inline single-OUTER core: j-stride 1 in __li_op_k preserved. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                         ? (__li_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (cmplx64_t) (0);
+                __li_buf_acc[__j] = (ca_u_cmplx64_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const cmplx64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+                const ca_u_cmplx64_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  cmplx64_t v = __li_row[__j];
+                  ca_u_cmplx64_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (cmplx64_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_cmplx64_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment OUTER multi-index (row-major over parent PRE dims). */
@@ -5947,7 +5947,7 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_CMPLX64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        cmplx64_t *op = (cmplx64_t *) co->ptr;
+        ca_u_cmplx64_t *op = (ca_u_cmplx64_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1). */
         ca_size_t __li_out_stride[CA_RANK_MAX];
@@ -5990,12 +5990,12 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
         ca_size_t __li_OUTER = 1;
         for ( int8_t __k = 0; __k < __li_eo_n; __k++ ) __li_OUTER *= __li_eo_dim[__k];
 
-          cmplx64_t  __li_buf_acc[512];
+          ca_u_cmplx64_t  __li_buf_acc[512];
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const cmplx64_t *p_root = (const cmplx64_t *) __li_st->parents[__kk]->ptr;
+          const ca_u_cmplx64_t *p_root = (const ca_u_cmplx64_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -6008,27 +6008,27 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
               __li_pbase += __li_idx[__i] * __li_eo_pstride[__i];
               __li_obase += __li_idx[__i] * __li_eo_ostride[__i];
             }
-            cmplx64_t *__li_op_k = op + __li_obase;
-            const cmplx64_t *__li_plane = p_root + __li_pbase;
+            ca_u_cmplx64_t *__li_op_k = op + __li_obase;
+            const ca_u_cmplx64_t *__li_plane = p_root + __li_pbase;
             /* L.7 core variant: M-step uses __li_M_stride, tile loop uses __li_eff_INNER. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_eff_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_eff_INNER - __li_tile < __li_TILE)
                                         ? (__li_eff_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (cmplx64_t) (0);
+                __li_buf_acc[__j] = (ca_u_cmplx64_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const cmplx64_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
+                const ca_u_cmplx64_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  cmplx64_t v = __li_row[__j];
+                  ca_u_cmplx64_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (cmplx64_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_cmplx64_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment effective OUTER multi-index. */
@@ -6047,7 +6047,7 @@ accumulate_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_CMPLX64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-cmplx64_t *op = (cmplx64_t *) co->ptr;
+ca_u_cmplx64_t *op = (ca_u_cmplx64_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -6060,10 +6060,10 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      cmplx64_t acc;
+      ca_u_cmplx64_t acc;
       ca_size_t masked_cnt = 0;
-#define __accumulate_cmplx64_EXPR(__x) ((cmplx64_t)(__x))
-      CA_SLAB_REDUCE_SUM8_EX(cmplx64_t, cmplx64_t, st, p, m, acc, 0, __accumulate_cmplx64_EXPR, masked_cnt);
+#define __accumulate_cmplx64_EXPR(__x) ((ca_u_cmplx64_t)(__x))
+      CA_SLAB_REDUCE_SUM8_EX(ca_u_cmplx64_t, ca_u_cmplx64_t, st, p, m, acc, 0, __accumulate_cmplx64_EXPR, masked_cnt);
 #undef __accumulate_cmplx64_EXPR
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
@@ -6071,9 +6071,9 @@ ca_size_t   out_i = 0;
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (cmplx64_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_cmplx64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (cmplx64_t) (acc);
+        op[out_i++] = (ca_u_cmplx64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -6108,18 +6108,18 @@ accumulate_ki_stream_cmplx128 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(cmplx128_t);
+      ca_size_t __s = sizeof(ca_u_cmplx128_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      cmplx128_t acc;
+      ca_u_cmplx128_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      cmplx128_t *__chunk = (cmplx128_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(cmplx128_t));
+      ca_u_cmplx128_t *__chunk = (ca_u_cmplx128_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_cmplx128_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -6129,12 +6129,12 @@ accumulate_ki_stream_cmplx128 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          cmplx128_t v = __chunk[__i];
+          ca_u_cmplx128_t v = __chunk[__i];
           acc += v;
         }
         __outer_off += __r;
       }
-      return CC2NUM((cmplx128_t) (acc));
+      return CC2NUM((ca_u_cmplx128_t) (acc));
 }
 
 static VALUE
@@ -6178,36 +6178,36 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_CMPLX128, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        cmplx128_t *op = (cmplx128_t *) co->ptr;
+        ca_u_cmplx128_t *op = (ca_u_cmplx128_t *) co->ptr;
         ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
-        const cmplx128_t *p_root = (const cmplx128_t *) ca->ptr;
+        const ca_u_cmplx128_t *p_root = (const ca_u_cmplx128_t *) ca->ptr;
 
         /* Per-buffer stack accumulators (one per :plus state, sized
            to L7 TILE = 512 cells regardless of INNER). */
-          cmplx128_t  __li_buf_acc[512];
+          ca_u_cmplx128_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const cmplx128_t *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_cmplx128_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (cmplx128_t) (0);
+                __li_buf_acc[__j] = (ca_u_cmplx128_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const cmplx128_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_cmplx128_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                cmplx128_t v = __li_row[__j];
+                ca_u_cmplx128_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              op[__li_o * __li_INNER + __li_tile + __j] = (cmplx128_t) (__li_buf_acc[__j]);
+              op[__li_o * __li_INNER + __li_tile + __j] = (ca_u_cmplx128_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -6258,37 +6258,37 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_CMPLX128, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        cmplx128_t *op = (cmplx128_t *) co->ptr;
+        ca_u_cmplx128_t *op = (ca_u_cmplx128_t *) co->ptr;
 
-          cmplx128_t  __li_buf_acc[512];
+          ca_u_cmplx128_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const cmplx128_t *p_root = (const cmplx128_t *) __li_st->parents[__kk]->ptr;
-          cmplx128_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
+          const ca_u_cmplx128_t *p_root = (const ca_u_cmplx128_t *) __li_st->parents[__kk]->ptr;
+          ca_u_cmplx128_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
-          const cmplx128_t *__li_plane = p_root + __li_o * __li_plane_elems;
+          const ca_u_cmplx128_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (cmplx128_t) (0);
+                __li_buf_acc[__j] = (ca_u_cmplx128_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-              const cmplx128_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+              const ca_u_cmplx128_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
               _Pragma("omp simd")
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                cmplx128_t v = __li_row[__j];
+                ca_u_cmplx128_t v = __li_row[__j];
                 __li_buf_acc[__j] += v;
                 (void) v;
               }
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (cmplx128_t) (__li_buf_acc[__j]);
+              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (ca_u_cmplx128_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -6349,7 +6349,7 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_CMPLX128, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        cmplx128_t *op = (cmplx128_t *) co->ptr;
+        ca_u_cmplx128_t *op = (ca_u_cmplx128_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1).
            Output position vo maps to view position vv = (vo < ax) ? vo : vo + 1. */
@@ -6378,13 +6378,13 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
           __li_pre_dim[__pd] = __li_p0->dim[__pd];
         }
 
-          cmplx128_t  __li_buf_acc[512];
+          ca_u_cmplx128_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const cmplx128_t *p_root = (const cmplx128_t *) __li_st->parents[__kk]->ptr;
+          const ca_u_cmplx128_t *p_root = (const ca_u_cmplx128_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -6395,27 +6395,27 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
             for ( int8_t __pd = 0; __pd < __li_pa; __pd++ ) {
               __li_obase += __li_idx[__pd] * __li_pre_out_stride[__pd];
             }
-            cmplx128_t *__li_op_k = op + __li_obase;
-            const cmplx128_t *__li_plane = p_root + __li_o * __li_plane_elems;
+            ca_u_cmplx128_t *__li_op_k = op + __li_obase;
+            const ca_u_cmplx128_t *__li_plane = p_root + __li_o * __li_plane_elems;
             /* Inline single-OUTER core: j-stride 1 in __li_op_k preserved. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                         ? (__li_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (cmplx128_t) (0);
+                __li_buf_acc[__j] = (ca_u_cmplx128_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const cmplx128_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
+                const ca_u_cmplx128_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  cmplx128_t v = __li_row[__j];
+                  ca_u_cmplx128_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (cmplx128_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_cmplx128_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment OUTER multi-index (row-major over parent PRE dims). */
@@ -6496,7 +6496,7 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_CMPLX128, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        cmplx128_t *op = (cmplx128_t *) co->ptr;
+        ca_u_cmplx128_t *op = (ca_u_cmplx128_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1). */
         ca_size_t __li_out_stride[CA_RANK_MAX];
@@ -6539,12 +6539,12 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
         ca_size_t __li_OUTER = 1;
         for ( int8_t __k = 0; __k < __li_eo_n; __k++ ) __li_OUTER *= __li_eo_dim[__k];
 
-          cmplx128_t  __li_buf_acc[512];
+          ca_u_cmplx128_t  __li_buf_acc[512];
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
-          const cmplx128_t *p_root = (const cmplx128_t *) __li_st->parents[__kk]->ptr;
+          const ca_u_cmplx128_t *p_root = (const ca_u_cmplx128_t *) __li_st->parents[__kk]->ptr;
           ca_size_t __li_k_base = (ca_size_t) __kk * __li_k_stride;
 
           ca_size_t __li_idx[CA_RANK_MAX];
@@ -6557,27 +6557,27 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
               __li_pbase += __li_idx[__i] * __li_eo_pstride[__i];
               __li_obase += __li_idx[__i] * __li_eo_ostride[__i];
             }
-            cmplx128_t *__li_op_k = op + __li_obase;
-            const cmplx128_t *__li_plane = p_root + __li_pbase;
+            ca_u_cmplx128_t *__li_op_k = op + __li_obase;
+            const ca_u_cmplx128_t *__li_plane = p_root + __li_pbase;
             /* L.7 core variant: M-step uses __li_M_stride, tile loop uses __li_eff_INNER. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_eff_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_eff_INNER - __li_tile < __li_TILE)
                                         ? (__li_eff_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (cmplx128_t) (0);
+                __li_buf_acc[__j] = (ca_u_cmplx128_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
-                const cmplx128_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
+                const ca_u_cmplx128_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
                 _Pragma("omp simd")
                 for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                  cmplx128_t v = __li_row[__j];
+                  ca_u_cmplx128_t v = __li_row[__j];
                   __li_buf_acc[__j] += v;
                   (void) v;
                 }
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (cmplx128_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_cmplx128_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment effective OUTER multi-index. */
@@ -6596,7 +6596,7 @@ accumulate_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_CMPLX128, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-cmplx128_t *op = (cmplx128_t *) co->ptr;
+ca_u_cmplx128_t *op = (ca_u_cmplx128_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -6609,10 +6609,10 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      cmplx128_t acc;
+      ca_u_cmplx128_t acc;
       ca_size_t masked_cnt = 0;
-#define __accumulate_cmplx128_EXPR(__x) ((cmplx128_t)(__x))
-      CA_SLAB_REDUCE_SUM8_EX(cmplx128_t, cmplx128_t, st, p, m, acc, 0, __accumulate_cmplx128_EXPR, masked_cnt);
+#define __accumulate_cmplx128_EXPR(__x) ((ca_u_cmplx128_t)(__x))
+      CA_SLAB_REDUCE_SUM8_EX(ca_u_cmplx128_t, ca_u_cmplx128_t, st, p, m, acc, 0, __accumulate_cmplx128_EXPR, masked_cnt);
 #undef __accumulate_cmplx128_EXPR
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
@@ -6620,9 +6620,9 @@ ca_size_t   out_i = 0;
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (cmplx128_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_cmplx128_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (cmplx128_t) (acc);
+        op[out_i++] = (ca_u_cmplx128_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -7470,7 +7470,7 @@ count_true_ki_stream_bool (VALUE arg)
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      int64_t acc;
+      ca_u_int64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
@@ -7489,7 +7489,7 @@ count_true_ki_stream_bool (VALUE arg)
         }
         __outer_off += __r;
       }
-      return LL2NUM((int64_t) (acc));
+      return LL2NUM((ca_u_int64_t) (acc));
 }
 
 static VALUE
@@ -7533,13 +7533,13 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int64_t *op = (int64_t *) co->ptr;
+        ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
         ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
         const boolean8_t *p_root = (const boolean8_t *) ca->ptr;
 
         /* Per-buffer stack accumulators (one per :plus state, sized
            to L7 TILE = 512 cells regardless of INNER). */
-          int64_t  __li_buf_acc[512];
+          ca_u_int64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
@@ -7549,7 +7549,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int64_t) (0);
+                __li_buf_acc[__j] = (ca_u_int64_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
               const boolean8_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
@@ -7562,7 +7562,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              op[__li_o * __li_INNER + __li_tile + __j] = (int64_t) (__li_buf_acc[__j]);
+              op[__li_o * __li_INNER + __li_tile + __j] = (ca_u_int64_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -7613,9 +7613,9 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int64_t *op = (int64_t *) co->ptr;
+        ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 
-          int64_t  __li_buf_acc[512];
+          ca_u_int64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
@@ -7623,14 +7623,14 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
           const boolean8_t *p_root = (const boolean8_t *) __li_st->parents[__kk]->ptr;
-          int64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
+          ca_u_int64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
           const boolean8_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int64_t) (0);
+                __li_buf_acc[__j] = (ca_u_int64_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
               const boolean8_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
@@ -7643,7 +7643,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (int64_t) (__li_buf_acc[__j]);
+              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (ca_u_int64_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -7704,7 +7704,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int64_t *op = (int64_t *) co->ptr;
+        ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1).
            Output position vo maps to view position vv = (vo < ax) ? vo : vo + 1. */
@@ -7733,7 +7733,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
           __li_pre_dim[__pd] = __li_p0->dim[__pd];
         }
 
-          int64_t  __li_buf_acc[512];
+          ca_u_int64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
@@ -7750,14 +7750,14 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
             for ( int8_t __pd = 0; __pd < __li_pa; __pd++ ) {
               __li_obase += __li_idx[__pd] * __li_pre_out_stride[__pd];
             }
-            int64_t *__li_op_k = op + __li_obase;
+            ca_u_int64_t *__li_op_k = op + __li_obase;
             const boolean8_t *__li_plane = p_root + __li_o * __li_plane_elems;
             /* Inline single-OUTER core: j-stride 1 in __li_op_k preserved. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                         ? (__li_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int64_t) (0);
+                __li_buf_acc[__j] = (ca_u_int64_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
                 const boolean8_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
@@ -7770,7 +7770,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (int64_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_int64_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment OUTER multi-index (row-major over parent PRE dims). */
@@ -7851,7 +7851,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int64_t *op = (int64_t *) co->ptr;
+        ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1). */
         ca_size_t __li_out_stride[CA_RANK_MAX];
@@ -7894,7 +7894,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
         ca_size_t __li_OUTER = 1;
         for ( int8_t __k = 0; __k < __li_eo_n; __k++ ) __li_OUTER *= __li_eo_dim[__k];
 
-          int64_t  __li_buf_acc[512];
+          ca_u_int64_t  __li_buf_acc[512];
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
@@ -7912,14 +7912,14 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
               __li_pbase += __li_idx[__i] * __li_eo_pstride[__i];
               __li_obase += __li_idx[__i] * __li_eo_ostride[__i];
             }
-            int64_t *__li_op_k = op + __li_obase;
+            ca_u_int64_t *__li_op_k = op + __li_obase;
             const boolean8_t *__li_plane = p_root + __li_pbase;
             /* L.7 core variant: M-step uses __li_M_stride, tile loop uses __li_eff_INNER. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_eff_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_eff_INNER - __li_tile < __li_TILE)
                                         ? (__li_eff_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int64_t) (0);
+                __li_buf_acc[__j] = (ca_u_int64_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
                 const boolean8_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
@@ -7932,7 +7932,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (int64_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_int64_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment effective OUTER multi-index. */
@@ -7951,7 +7951,7 @@ count_true_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-int64_t *op = (int64_t *) co->ptr;
+ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -7964,10 +7964,10 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      int64_t acc;
+      ca_u_int64_t acc;
       ca_size_t masked_cnt = 0;
-#define __count_true_bool_EXPR(__x) ((int64_t)(__x))
-      CA_SLAB_REDUCE_SUM8_EX(boolean8_t, int64_t, st, p, m, acc, 0, __count_true_bool_EXPR, masked_cnt);
+#define __count_true_bool_EXPR(__x) ((ca_u_int64_t)(__x))
+      CA_SLAB_REDUCE_SUM8_EX(boolean8_t, ca_u_int64_t, st, p, m, acc, 0, __count_true_bool_EXPR, masked_cnt);
 #undef __count_true_bool_EXPR
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
@@ -7975,9 +7975,9 @@ ca_size_t   out_i = 0;
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (int64_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_int64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (int64_t) (acc);
+        op[out_i++] = (ca_u_int64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -8066,7 +8066,7 @@ count_false_ki_stream_bool (VALUE arg)
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      int64_t acc;
+      ca_u_int64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
@@ -8085,7 +8085,7 @@ count_false_ki_stream_bool (VALUE arg)
         }
         __outer_off += __r;
       }
-      return LL2NUM((int64_t) (acc));
+      return LL2NUM((ca_u_int64_t) (acc));
 }
 
 static VALUE
@@ -8129,13 +8129,13 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int64_t *op = (int64_t *) co->ptr;
+        ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
         ca_attach(ca);   /* window: numeric lanes only, nothing raises inside; O(1) alias attach */
         const boolean8_t *p_root = (const boolean8_t *) ca->ptr;
 
         /* Per-buffer stack accumulators (one per :plus state, sized
            to L7 TILE = 512 cells regardless of INNER). */
-          int64_t  __li_buf_acc[512];
+          ca_u_int64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
@@ -8145,7 +8145,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int64_t) (0);
+                __li_buf_acc[__j] = (ca_u_int64_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
               const boolean8_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
@@ -8158,7 +8158,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              op[__li_o * __li_INNER + __li_tile + __j] = (int64_t) (__li_buf_acc[__j]);
+              op[__li_o * __li_INNER + __li_tile + __j] = (ca_u_int64_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -8209,9 +8209,9 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int64_t *op = (int64_t *) co->ptr;
+        ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 
-          int64_t  __li_buf_acc[512];
+          ca_u_int64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         ca_size_t __li_parent_out  = __li_OUTER * __li_INNER;
@@ -8219,14 +8219,14 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
           ca_attach(__li_st->parents[__kk]);   /* window: numeric lanes only, nothing raises inside */
           const boolean8_t *p_root = (const boolean8_t *) __li_st->parents[__kk]->ptr;
-          int64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
+          ca_u_int64_t *__li_op_k = op + (ca_size_t) __kk * __li_parent_out;
         for ( ca_size_t __li_o = 0; __li_o < __li_OUTER; __li_o++ ) {
           const boolean8_t *__li_plane = p_root + __li_o * __li_plane_elems;
           for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
             ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                       ? (__li_INNER - __li_tile) : __li_TILE;
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int64_t) (0);
+                __li_buf_acc[__j] = (ca_u_int64_t) (0);
               }
             for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
               const boolean8_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
@@ -8239,7 +8239,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
             }
 
             for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (int64_t) (__li_buf_acc[__j]);
+              __li_op_k[__li_o * __li_INNER + __li_tile + __j] = (ca_u_int64_t) (__li_buf_acc[__j]);
             }
           }
         }
@@ -8300,7 +8300,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int64_t *op = (int64_t *) co->ptr;
+        ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1).
            Output position vo maps to view position vv = (vo < ax) ? vo : vo + 1. */
@@ -8329,7 +8329,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
           __li_pre_dim[__pd] = __li_p0->dim[__pd];
         }
 
-          int64_t  __li_buf_acc[512];
+          ca_u_int64_t  __li_buf_acc[512];
 
         ca_size_t __li_plane_elems = __li_M * __li_INNER;
         const ca_size_t __li_TILE = 512;
@@ -8346,14 +8346,14 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
             for ( int8_t __pd = 0; __pd < __li_pa; __pd++ ) {
               __li_obase += __li_idx[__pd] * __li_pre_out_stride[__pd];
             }
-            int64_t *__li_op_k = op + __li_obase;
+            ca_u_int64_t *__li_op_k = op + __li_obase;
             const boolean8_t *__li_plane = p_root + __li_o * __li_plane_elems;
             /* Inline single-OUTER core: j-stride 1 in __li_op_k preserved. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_INNER - __li_tile < __li_TILE)
                                         ? (__li_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int64_t) (0);
+                __li_buf_acc[__j] = (ca_u_int64_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
                 const boolean8_t *__li_row = __li_plane + __li_i * __li_INNER + __li_tile;
@@ -8366,7 +8366,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (int64_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_int64_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment OUTER multi-index (row-major over parent PRE dims). */
@@ -8447,7 +8447,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
         VALUE   vout = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
         CArray *co;
         GetCArray(vout, co);
-        int64_t *op = (int64_t *) co->ptr;
+        ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 
         /* Output row-major stride table (length = ca->ndim - 1). */
         ca_size_t __li_out_stride[CA_RANK_MAX];
@@ -8490,7 +8490,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
         ca_size_t __li_OUTER = 1;
         for ( int8_t __k = 0; __k < __li_eo_n; __k++ ) __li_OUTER *= __li_eo_dim[__k];
 
-          int64_t  __li_buf_acc[512];
+          ca_u_int64_t  __li_buf_acc[512];
 
         const ca_size_t __li_TILE = 512;
         for ( int32_t __kk = 0; __kk < __li_st->n_parents; __kk++ ) {
@@ -8508,14 +8508,14 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
               __li_pbase += __li_idx[__i] * __li_eo_pstride[__i];
               __li_obase += __li_idx[__i] * __li_eo_ostride[__i];
             }
-            int64_t *__li_op_k = op + __li_obase;
+            ca_u_int64_t *__li_op_k = op + __li_obase;
             const boolean8_t *__li_plane = p_root + __li_pbase;
             /* L.7 core variant: M-step uses __li_M_stride, tile loop uses __li_eff_INNER. */
             for ( ca_size_t __li_tile = 0; __li_tile < __li_eff_INNER; __li_tile += __li_TILE ) {
               ca_size_t __li_tile_len = (__li_eff_INNER - __li_tile < __li_TILE)
                                         ? (__li_eff_INNER - __li_tile) : __li_TILE;
                   for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_buf_acc[__j] = (int64_t) (0);
+                __li_buf_acc[__j] = (ca_u_int64_t) (0);
               }
               for ( ca_size_t __li_i = 0; __li_i < __li_M; __li_i++ ) {
                 const boolean8_t *__li_row = __li_plane + __li_i * __li_M_stride + __li_tile;
@@ -8528,7 +8528,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
               }
     
               for ( ca_size_t __j = 0; __j < __li_tile_len; __j++ ) {
-                __li_op_k[__li_tile + __j] = (int64_t) (__li_buf_acc[__j]);
+                __li_op_k[__li_tile + __j] = (ca_u_int64_t) (__li_buf_acc[__j]);
               }
             }
             /* Carry-increment effective OUTER multi-index. */
@@ -8547,7 +8547,7 @@ count_false_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t na
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-int64_t *op = (int64_t *) co->ptr;
+ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -8560,7 +8560,7 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      int64_t acc;
+      ca_u_int64_t acc;
       ca_size_t masked_cnt = 0;
       CA_SLAB_REDUCE_T_PLUS_EX(boolean8_t, st, p, m, acc, 0, acc += !v, masked_cnt);
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
@@ -8569,9 +8569,9 @@ ca_size_t   out_i = 0;
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (int64_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_int64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (int64_t) (acc);
+        op[out_i++] = (ca_u_int64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -8663,7 +8663,7 @@ count_equal_ki_stream_i8 (VALUE arg)
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      int64_t acc;
+      ca_u_int64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
@@ -8682,7 +8682,7 @@ count_equal_ki_stream_i8 (VALUE arg)
         }
         __outer_off += __r;
       }
-      return LL2NUM((int64_t) (acc));
+      return LL2NUM((ca_u_int64_t) (acc));
 }
 
 static VALUE
@@ -8704,7 +8704,7 @@ count_equal_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-int64_t *op = (int64_t *) co->ptr;
+ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -8717,7 +8717,7 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      int64_t acc;
+      ca_u_int64_t acc;
       ca_size_t masked_cnt = 0;
       CA_SLAB_REDUCE_T_PLUS_EX(int8_t, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
@@ -8726,9 +8726,9 @@ ca_size_t   out_i = 0;
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (int64_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_int64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (int64_t) (acc);
+        op[out_i++] = (ca_u_int64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -8773,7 +8773,7 @@ count_equal_ki_stream_u8 (VALUE arg)
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      int64_t acc;
+      ca_u_int64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
@@ -8792,7 +8792,7 @@ count_equal_ki_stream_u8 (VALUE arg)
         }
         __outer_off += __r;
       }
-      return LL2NUM((int64_t) (acc));
+      return LL2NUM((ca_u_int64_t) (acc));
 }
 
 static VALUE
@@ -8814,7 +8814,7 @@ count_equal_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxe
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-int64_t *op = (int64_t *) co->ptr;
+ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -8827,7 +8827,7 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      int64_t acc;
+      ca_u_int64_t acc;
       ca_size_t masked_cnt = 0;
       CA_SLAB_REDUCE_T_PLUS_EX(uint8_t, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
@@ -8836,9 +8836,9 @@ ca_size_t   out_i = 0;
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (int64_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_int64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (int64_t) (acc);
+        op[out_i++] = (ca_u_int64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -8852,7 +8852,7 @@ ca_size_t   out_i = 0;
 typedef struct {
   void      *chunk;
   CArray    *ca;
-  int16_t value_arg;
+  ca_u_int16_t value_arg;
   ca_size_t  min_count;
 } count_equal_ki_stream_i16_t;
 
@@ -8861,7 +8861,7 @@ count_equal_ki_stream_i16 (VALUE arg)
 {
       count_equal_ki_stream_i16_t *__ctx = (count_equal_ki_stream_i16_t *) arg;
       CArray *ca = __ctx->ca;
-      int16_t value_arg = __ctx->value_arg;
+      ca_u_int16_t value_arg = __ctx->value_arg;
       (void) value_arg;
       ca_size_t min_count = __ctx->min_count;
       (void) min_count;
@@ -8876,18 +8876,18 @@ count_equal_ki_stream_i16 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(int16_t);
+      ca_size_t __s = sizeof(ca_u_int16_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      int64_t acc;
+      ca_u_int64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      int16_t *__chunk = (int16_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(int16_t));
+      ca_u_int16_t *__chunk = (ca_u_int16_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_int16_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -8897,16 +8897,16 @@ count_equal_ki_stream_i16 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          int16_t v = __chunk[__i];
+          ca_u_int16_t v = __chunk[__i];
           if (v == value_arg) acc += 1;
         }
         __outer_off += __r;
       }
-      return LL2NUM((int64_t) (acc));
+      return LL2NUM((ca_u_int64_t) (acc));
 }
 
 static VALUE
-count_equal_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, int16_t value_arg, ca_size_t min_count)
+count_equal_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_int16_t value_arg, ca_size_t min_count)
 {
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
@@ -8924,7 +8924,7 @@ count_equal_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-int64_t *op = (int64_t *) co->ptr;
+ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -8937,18 +8937,18 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      int64_t acc;
+      ca_u_int64_t acc;
       ca_size_t masked_cnt = 0;
-      CA_SLAB_REDUCE_T_PLUS_EX(int16_t, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
+      CA_SLAB_REDUCE_T_PLUS_EX(ca_u_int16_t, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
           ca_create_mask(co);
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (int64_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_int64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (int64_t) (acc);
+        op[out_i++] = (ca_u_int64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -8962,7 +8962,7 @@ ca_size_t   out_i = 0;
 typedef struct {
   void      *chunk;
   CArray    *ca;
-  uint16_t value_arg;
+  ca_u_uint16_t value_arg;
   ca_size_t  min_count;
 } count_equal_ki_stream_u16_t;
 
@@ -8971,7 +8971,7 @@ count_equal_ki_stream_u16 (VALUE arg)
 {
       count_equal_ki_stream_u16_t *__ctx = (count_equal_ki_stream_u16_t *) arg;
       CArray *ca = __ctx->ca;
-      uint16_t value_arg = __ctx->value_arg;
+      ca_u_uint16_t value_arg = __ctx->value_arg;
       (void) value_arg;
       ca_size_t min_count = __ctx->min_count;
       (void) min_count;
@@ -8986,18 +8986,18 @@ count_equal_ki_stream_u16 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(uint16_t);
+      ca_size_t __s = sizeof(ca_u_uint16_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      int64_t acc;
+      ca_u_int64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      uint16_t *__chunk = (uint16_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(uint16_t));
+      ca_u_uint16_t *__chunk = (ca_u_uint16_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_uint16_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -9007,16 +9007,16 @@ count_equal_ki_stream_u16 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          uint16_t v = __chunk[__i];
+          ca_u_uint16_t v = __chunk[__i];
           if (v == value_arg) acc += 1;
         }
         __outer_off += __r;
       }
-      return LL2NUM((int64_t) (acc));
+      return LL2NUM((ca_u_int64_t) (acc));
 }
 
 static VALUE
-count_equal_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, uint16_t value_arg, ca_size_t min_count)
+count_equal_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_uint16_t value_arg, ca_size_t min_count)
 {
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
@@ -9034,7 +9034,7 @@ count_equal_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-int64_t *op = (int64_t *) co->ptr;
+ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -9047,18 +9047,18 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      int64_t acc;
+      ca_u_int64_t acc;
       ca_size_t masked_cnt = 0;
-      CA_SLAB_REDUCE_T_PLUS_EX(uint16_t, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
+      CA_SLAB_REDUCE_T_PLUS_EX(ca_u_uint16_t, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
           ca_create_mask(co);
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (int64_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_int64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (int64_t) (acc);
+        op[out_i++] = (ca_u_int64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -9072,7 +9072,7 @@ ca_size_t   out_i = 0;
 typedef struct {
   void      *chunk;
   CArray    *ca;
-  int32_t value_arg;
+  ca_u_int32_t value_arg;
   ca_size_t  min_count;
 } count_equal_ki_stream_i32_t;
 
@@ -9081,7 +9081,7 @@ count_equal_ki_stream_i32 (VALUE arg)
 {
       count_equal_ki_stream_i32_t *__ctx = (count_equal_ki_stream_i32_t *) arg;
       CArray *ca = __ctx->ca;
-      int32_t value_arg = __ctx->value_arg;
+      ca_u_int32_t value_arg = __ctx->value_arg;
       (void) value_arg;
       ca_size_t min_count = __ctx->min_count;
       (void) min_count;
@@ -9096,18 +9096,18 @@ count_equal_ki_stream_i32 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(int32_t);
+      ca_size_t __s = sizeof(ca_u_int32_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      int64_t acc;
+      ca_u_int64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      int32_t *__chunk = (int32_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(int32_t));
+      ca_u_int32_t *__chunk = (ca_u_int32_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_int32_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -9117,16 +9117,16 @@ count_equal_ki_stream_i32 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          int32_t v = __chunk[__i];
+          ca_u_int32_t v = __chunk[__i];
           if (v == value_arg) acc += 1;
         }
         __outer_off += __r;
       }
-      return LL2NUM((int64_t) (acc));
+      return LL2NUM((ca_u_int64_t) (acc));
 }
 
 static VALUE
-count_equal_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, int32_t value_arg, ca_size_t min_count)
+count_equal_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_int32_t value_arg, ca_size_t min_count)
 {
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
@@ -9144,7 +9144,7 @@ count_equal_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-int64_t *op = (int64_t *) co->ptr;
+ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -9157,18 +9157,18 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      int64_t acc;
+      ca_u_int64_t acc;
       ca_size_t masked_cnt = 0;
-      CA_SLAB_REDUCE_T_PLUS_EX(int32_t, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
+      CA_SLAB_REDUCE_T_PLUS_EX(ca_u_int32_t, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
           ca_create_mask(co);
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (int64_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_int64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (int64_t) (acc);
+        op[out_i++] = (ca_u_int64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -9182,7 +9182,7 @@ ca_size_t   out_i = 0;
 typedef struct {
   void      *chunk;
   CArray    *ca;
-  uint32_t value_arg;
+  ca_u_uint32_t value_arg;
   ca_size_t  min_count;
 } count_equal_ki_stream_u32_t;
 
@@ -9191,7 +9191,7 @@ count_equal_ki_stream_u32 (VALUE arg)
 {
       count_equal_ki_stream_u32_t *__ctx = (count_equal_ki_stream_u32_t *) arg;
       CArray *ca = __ctx->ca;
-      uint32_t value_arg = __ctx->value_arg;
+      ca_u_uint32_t value_arg = __ctx->value_arg;
       (void) value_arg;
       ca_size_t min_count = __ctx->min_count;
       (void) min_count;
@@ -9206,18 +9206,18 @@ count_equal_ki_stream_u32 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(uint32_t);
+      ca_size_t __s = sizeof(ca_u_uint32_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      int64_t acc;
+      ca_u_int64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      uint32_t *__chunk = (uint32_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(uint32_t));
+      ca_u_uint32_t *__chunk = (ca_u_uint32_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_uint32_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -9227,16 +9227,16 @@ count_equal_ki_stream_u32 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          uint32_t v = __chunk[__i];
+          ca_u_uint32_t v = __chunk[__i];
           if (v == value_arg) acc += 1;
         }
         __outer_off += __r;
       }
-      return LL2NUM((int64_t) (acc));
+      return LL2NUM((ca_u_int64_t) (acc));
 }
 
 static VALUE
-count_equal_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, uint32_t value_arg, ca_size_t min_count)
+count_equal_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_uint32_t value_arg, ca_size_t min_count)
 {
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
@@ -9254,7 +9254,7 @@ count_equal_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-int64_t *op = (int64_t *) co->ptr;
+ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -9267,18 +9267,18 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      int64_t acc;
+      ca_u_int64_t acc;
       ca_size_t masked_cnt = 0;
-      CA_SLAB_REDUCE_T_PLUS_EX(uint32_t, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
+      CA_SLAB_REDUCE_T_PLUS_EX(ca_u_uint32_t, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
           ca_create_mask(co);
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (int64_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_int64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (int64_t) (acc);
+        op[out_i++] = (ca_u_int64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -9292,7 +9292,7 @@ ca_size_t   out_i = 0;
 typedef struct {
   void      *chunk;
   CArray    *ca;
-  int64_t value_arg;
+  ca_u_int64_t value_arg;
   ca_size_t  min_count;
 } count_equal_ki_stream_i64_t;
 
@@ -9301,7 +9301,7 @@ count_equal_ki_stream_i64 (VALUE arg)
 {
       count_equal_ki_stream_i64_t *__ctx = (count_equal_ki_stream_i64_t *) arg;
       CArray *ca = __ctx->ca;
-      int64_t value_arg = __ctx->value_arg;
+      ca_u_int64_t value_arg = __ctx->value_arg;
       (void) value_arg;
       ca_size_t min_count = __ctx->min_count;
       (void) min_count;
@@ -9316,18 +9316,18 @@ count_equal_ki_stream_i64 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(int64_t);
+      ca_size_t __s = sizeof(ca_u_int64_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      int64_t acc;
+      ca_u_int64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      int64_t *__chunk = (int64_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(int64_t));
+      ca_u_int64_t *__chunk = (ca_u_int64_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_int64_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -9337,16 +9337,16 @@ count_equal_ki_stream_i64 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          int64_t v = __chunk[__i];
+          ca_u_int64_t v = __chunk[__i];
           if (v == value_arg) acc += 1;
         }
         __outer_off += __r;
       }
-      return LL2NUM((int64_t) (acc));
+      return LL2NUM((ca_u_int64_t) (acc));
 }
 
 static VALUE
-count_equal_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, int64_t value_arg, ca_size_t min_count)
+count_equal_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_int64_t value_arg, ca_size_t min_count)
 {
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
@@ -9364,7 +9364,7 @@ count_equal_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-int64_t *op = (int64_t *) co->ptr;
+ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -9377,18 +9377,18 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      int64_t acc;
+      ca_u_int64_t acc;
       ca_size_t masked_cnt = 0;
-      CA_SLAB_REDUCE_T_PLUS_EX(int64_t, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
+      CA_SLAB_REDUCE_T_PLUS_EX(ca_u_int64_t, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
           ca_create_mask(co);
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (int64_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_int64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (int64_t) (acc);
+        op[out_i++] = (ca_u_int64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -9402,7 +9402,7 @@ ca_size_t   out_i = 0;
 typedef struct {
   void      *chunk;
   CArray    *ca;
-  uint64_t value_arg;
+  ca_u_uint64_t value_arg;
   ca_size_t  min_count;
 } count_equal_ki_stream_u64_t;
 
@@ -9411,7 +9411,7 @@ count_equal_ki_stream_u64 (VALUE arg)
 {
       count_equal_ki_stream_u64_t *__ctx = (count_equal_ki_stream_u64_t *) arg;
       CArray *ca = __ctx->ca;
-      uint64_t value_arg = __ctx->value_arg;
+      ca_u_uint64_t value_arg = __ctx->value_arg;
       (void) value_arg;
       ca_size_t min_count = __ctx->min_count;
       (void) min_count;
@@ -9426,18 +9426,18 @@ count_equal_ki_stream_u64 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(uint64_t);
+      ca_size_t __s = sizeof(ca_u_uint64_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      int64_t acc;
+      ca_u_int64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      uint64_t *__chunk = (uint64_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(uint64_t));
+      ca_u_uint64_t *__chunk = (ca_u_uint64_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_uint64_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -9447,16 +9447,16 @@ count_equal_ki_stream_u64 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          uint64_t v = __chunk[__i];
+          ca_u_uint64_t v = __chunk[__i];
           if (v == value_arg) acc += 1;
         }
         __outer_off += __r;
       }
-      return LL2NUM((int64_t) (acc));
+      return LL2NUM((ca_u_int64_t) (acc));
 }
 
 static VALUE
-count_equal_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, uint64_t value_arg, ca_size_t min_count)
+count_equal_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_uint64_t value_arg, ca_size_t min_count)
 {
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
@@ -9474,7 +9474,7 @@ count_equal_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-int64_t *op = (int64_t *) co->ptr;
+ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -9487,18 +9487,18 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      int64_t acc;
+      ca_u_int64_t acc;
       ca_size_t masked_cnt = 0;
-      CA_SLAB_REDUCE_T_PLUS_EX(uint64_t, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
+      CA_SLAB_REDUCE_T_PLUS_EX(ca_u_uint64_t, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
           ca_create_mask(co);
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (int64_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_int64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (int64_t) (acc);
+        op[out_i++] = (ca_u_int64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -9512,7 +9512,7 @@ ca_size_t   out_i = 0;
 typedef struct {
   void      *chunk;
   CArray    *ca;
-  float value_arg;
+  ca_u_float32_t value_arg;
   ca_size_t  min_count;
 } count_equal_ki_stream_f32_t;
 
@@ -9521,7 +9521,7 @@ count_equal_ki_stream_f32 (VALUE arg)
 {
       count_equal_ki_stream_f32_t *__ctx = (count_equal_ki_stream_f32_t *) arg;
       CArray *ca = __ctx->ca;
-      float value_arg = __ctx->value_arg;
+      ca_u_float32_t value_arg = __ctx->value_arg;
       (void) value_arg;
       ca_size_t min_count = __ctx->min_count;
       (void) min_count;
@@ -9536,18 +9536,18 @@ count_equal_ki_stream_f32 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(float);
+      ca_size_t __s = sizeof(ca_u_float32_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      int64_t acc;
+      ca_u_int64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      float *__chunk = (float *) ca_lazy_arena_acquire(__chunk_elems * sizeof(float));
+      ca_u_float32_t *__chunk = (ca_u_float32_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_float32_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -9557,16 +9557,16 @@ count_equal_ki_stream_f32 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          float v = __chunk[__i];
+          ca_u_float32_t v = __chunk[__i];
           if (v == value_arg) acc += 1;
         }
         __outer_off += __r;
       }
-      return LL2NUM((int64_t) (acc));
+      return LL2NUM((ca_u_int64_t) (acc));
 }
 
 static VALUE
-count_equal_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, float value_arg, ca_size_t min_count)
+count_equal_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_float32_t value_arg, ca_size_t min_count)
 {
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
@@ -9584,7 +9584,7 @@ count_equal_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-int64_t *op = (int64_t *) co->ptr;
+ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -9597,18 +9597,18 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      int64_t acc;
+      ca_u_int64_t acc;
       ca_size_t masked_cnt = 0;
-      CA_SLAB_REDUCE_T_PLUS_EX(float, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
+      CA_SLAB_REDUCE_T_PLUS_EX(ca_u_float32_t, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
           ca_create_mask(co);
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (int64_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_int64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (int64_t) (acc);
+        op[out_i++] = (ca_u_int64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -9622,7 +9622,7 @@ ca_size_t   out_i = 0;
 typedef struct {
   void      *chunk;
   CArray    *ca;
-  double value_arg;
+  ca_u_float64_t value_arg;
   ca_size_t  min_count;
 } count_equal_ki_stream_f64_t;
 
@@ -9631,7 +9631,7 @@ count_equal_ki_stream_f64 (VALUE arg)
 {
       count_equal_ki_stream_f64_t *__ctx = (count_equal_ki_stream_f64_t *) arg;
       CArray *ca = __ctx->ca;
-      double value_arg = __ctx->value_arg;
+      ca_u_float64_t value_arg = __ctx->value_arg;
       (void) value_arg;
       ca_size_t min_count = __ctx->min_count;
       (void) min_count;
@@ -9646,18 +9646,18 @@ count_equal_ki_stream_f64 (VALUE arg)
       ca_size_t __starts[CA_RANK_MAX]  = {0};
       ca_size_t __counts[CA_RANK_MAX];
       ca_size_t __strides[CA_RANK_MAX];
-      ca_size_t __s = sizeof(double);
+      ca_size_t __s = sizeof(ca_u_float64_t);
       for ( __k = ca->ndim - 1; __k >= 0; __k-- ) {
         __strides[__k] = __s;
         __s *= ca->dim[__k];
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      int64_t acc;
+      ca_u_int64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
-      double *__chunk = (double *) ca_lazy_arena_acquire(__chunk_elems * sizeof(double));
+      ca_u_float64_t *__chunk = (ca_u_float64_t *) ca_lazy_arena_acquire(__chunk_elems * sizeof(ca_u_float64_t));
       __ctx->chunk = __chunk;
       while ( __outer_off < __outer ) {
         ca_size_t __r = (__outer - __outer_off < __rows) ? (__outer - __outer_off) : __rows;
@@ -9667,16 +9667,16 @@ count_equal_ki_stream_f64 (VALUE arg)
         ca_xfer_stride(ca, __starts, __counts, __strides, __chunk, CA_XFER_GET);
         ca_size_t __i;
         for ( __i = 0; __i < __n; __i++ ) {
-          double v = __chunk[__i];
+          ca_u_float64_t v = __chunk[__i];
           if (v == value_arg) acc += 1;
         }
         __outer_off += __r;
       }
-      return LL2NUM((int64_t) (acc));
+      return LL2NUM((ca_u_int64_t) (acc));
 }
 
 static VALUE
-count_equal_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, double value_arg, ca_size_t min_count)
+count_equal_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_u_float64_t value_arg, ca_size_t min_count)
 {
     if ( naxes == ca->ndim && ca->ndim >= 1 && !keep_axis &&
          ca->elements > 0 &&
@@ -9694,7 +9694,7 @@ count_equal_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t nax
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-int64_t *op = (int64_t *) co->ptr;
+ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 ca_iter_state st;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
@@ -9707,18 +9707,18 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      int64_t acc;
+      ca_u_int64_t acc;
       ca_size_t masked_cnt = 0;
-      CA_SLAB_REDUCE_T_PLUS_EX(double, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
+      CA_SLAB_REDUCE_T_PLUS_EX(ca_u_float64_t, st, p, m, acc, 0, if (v == value_arg) acc += 1, masked_cnt);
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
         if ( ! op_mask ) {
           ca_create_mask(co);
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (int64_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_int64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (int64_t) (acc);
+        op[out_i++] = (ca_u_int64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -9763,7 +9763,7 @@ count_equal_ki_stream_object (VALUE arg)
       }
       for ( __k = 1; __k < ca->ndim; __k++ ) __counts[__k] = ca->dim[__k];
       ca_size_t __outer_off = 0;
-      int64_t acc;
+      ca_u_int64_t acc;
       acc = (0);
       ca_size_t masked_cnt = 0;  /* unused on streaming (no mask) */
       (void) masked_cnt;
@@ -9782,7 +9782,7 @@ count_equal_ki_stream_object (VALUE arg)
         }
         __outer_off += __r;
       }
-      return LL2NUM((int64_t) (acc));
+      return LL2NUM((ca_u_int64_t) (acc));
 }
 
 /* The object lane calls Ruby for every cell, so a walk can raise part
@@ -9834,7 +9834,7 @@ count_equal_ki_native_object_body (VALUE arg)
 VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_INT64, keep_axis);
 CArray *co;
 GetCArray(vout, co);
-int64_t *op = (int64_t *) co->ptr;
+ca_u_int64_t *op = (ca_u_int64_t *) co->ptr;
 int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
                                slab_axes, naxes, 0);
 if ( rc != CA_ITER_OK ) {
@@ -9846,7 +9846,7 @@ boolean8_t *m;
 ca_size_t   out_i = 0;
       boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
       while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
-      int64_t acc;
+      ca_u_int64_t acc;
       ca_size_t masked_cnt = 0;
       CA_SLAB_REDUCE_T_EX(VALUE, st, p, m, acc, 0, if (ca_obj_equal(v, value_arg)) acc += 1, masked_cnt);
       if ( ca_too_few_present(st.slab_elements - masked_cnt, min_count, 0) ) {
@@ -9855,9 +9855,9 @@ ca_size_t   out_i = 0;
           op_mask = (boolean8_t *) co->mask->ptr;
         }
         op_mask[out_i] = 1;
-        op[out_i++] = (int64_t) 0;   /* sentinel; mask bit is what counts */
+        op[out_i++] = (ca_u_int64_t) 0;   /* sentinel; mask bit is what counts */
       } else {
-        op[out_i++] = (int64_t) (acc);
+        op[out_i++] = (ca_u_int64_t) (acc);
       }
       }
       ca_iter_state_finish(&st);
@@ -10002,54 +10002,54 @@ rb_ca_count_equal_ki (int argc, VALUE *argv, VALUE self)
     }
     case CA_INT16: {
       ca_check_integer_fits(rval, CA_INT16);
-      int16_t value_arg = (int16_t) NUM2LL(rval);
+      ca_u_int16_t value_arg = (ca_u_int16_t) NUM2LL(rval);
       result = count_equal_ki_native_i16(self, src, slab_axes, naxes, keep_axis, value_arg, min_count);
       RB_GC_GUARD(self);
       break;
     }
     case CA_UINT16: {
       ca_check_integer_fits(rval, CA_UINT16);
-      uint16_t value_arg = (uint16_t) NUM2ULL(rval);
+      ca_u_uint16_t value_arg = (ca_u_uint16_t) NUM2ULL(rval);
       result = count_equal_ki_native_u16(self, src, slab_axes, naxes, keep_axis, value_arg, min_count);
       RB_GC_GUARD(self);
       break;
     }
     case CA_INT32: {
       ca_check_integer_fits(rval, CA_INT32);
-      int32_t value_arg = (int32_t) NUM2LL(rval);
+      ca_u_int32_t value_arg = (ca_u_int32_t) NUM2LL(rval);
       result = count_equal_ki_native_i32(self, src, slab_axes, naxes, keep_axis, value_arg, min_count);
       RB_GC_GUARD(self);
       break;
     }
     case CA_UINT32: {
       ca_check_integer_fits(rval, CA_UINT32);
-      uint32_t value_arg = (uint32_t) NUM2ULL(rval);
+      ca_u_uint32_t value_arg = (ca_u_uint32_t) NUM2ULL(rval);
       result = count_equal_ki_native_u32(self, src, slab_axes, naxes, keep_axis, value_arg, min_count);
       RB_GC_GUARD(self);
       break;
     }
     case CA_INT64: {
       ca_check_integer_fits(rval, CA_INT64);
-      int64_t value_arg = (int64_t) NUM2LL(rval);
+      ca_u_int64_t value_arg = (ca_u_int64_t) NUM2LL(rval);
       result = count_equal_ki_native_i64(self, src, slab_axes, naxes, keep_axis, value_arg, min_count);
       RB_GC_GUARD(self);
       break;
     }
     case CA_UINT64: {
       ca_check_integer_fits(rval, CA_UINT64);
-      uint64_t value_arg = (uint64_t) NUM2ULL(rval);
+      ca_u_uint64_t value_arg = (ca_u_uint64_t) NUM2ULL(rval);
       result = count_equal_ki_native_u64(self, src, slab_axes, naxes, keep_axis, value_arg, min_count);
       RB_GC_GUARD(self);
       break;
     }
     case CA_FLOAT32: {
-      float value_arg = (float) NUM2DBL(rval);
+      ca_u_float32_t value_arg = (ca_u_float32_t) NUM2DBL(rval);
       result = count_equal_ki_native_f32(self, src, slab_axes, naxes, keep_axis, value_arg, min_count);
       RB_GC_GUARD(self);
       break;
     }
     case CA_FLOAT64: {
-      double value_arg = (double) NUM2DBL(rval);
+      ca_u_float64_t value_arg = (ca_u_float64_t) NUM2DBL(rval);
       result = count_equal_ki_native_f64(self, src, slab_axes, naxes, keep_axis, value_arg, min_count);
       RB_GC_GUARD(self);
       break;