numkong 7.0.0 → 7.4.1

package/include/numkong/sets/smebi32.h

@@ -65,7 +65,7 @@ extern "C" {
  */
 
 #if defined(__clang__)
-#pragma clang attribute push(__attribute__((target("sme2,sve2"))), apply_to = function)
+#pragma clang attribute push(__attribute__((target("sme2"))), apply_to = function)
 #elif defined(__GNUC__)
 #pragma GCC push_options
 #pragma GCC target("+sme2")
@@ -93,13 +93,12 @@ typedef struct {
 
 /** Count total set bits across a byte vector using streaming SVE.
  *  Accumulates per-byte popcounts into u32 lanes via svdot; single horizontal reduction at end. */
-NK_PUBLIC nk_u32_t nk_sets_reduce_sumsq_u1_streaming_(nk_u1x8_t const *data,
-                                                      nk_size_t n_bytes) NK_STREAMING_COMPATIBLE_ {
+NK_PUBLIC nk_u32_t nk_sets_reduce_sumsq_u1_streaming_(nk_u1x8_t const *data, nk_size_t n_bytes) NK_STREAMING_ {
     svuint32_t acc_u32x = svdup_u32(0);
     svuint8_t const ones_u8x = svdup_u8(1);
     for (nk_size_t offset = 0; offset < n_bytes; offset += svcntb()) {
-        svbool_t predicate_u8x = svwhilelt_b8_u64(offset, n_bytes);
-        acc_u32x = svdot_u32(acc_u32x, svcnt_u8_z(predicate_u8x, svld1_u8(predicate_u8x, data + offset)), ones_u8x);
+        svbool_t predicate_b8x = svwhilelt_b8_u64(offset, n_bytes);
+        acc_u32x = svdot_u32(acc_u32x, svcnt_u8_z(predicate_b8x, svld1_u8(predicate_b8x, data + offset)), ones_u8x);
     }
     return (nk_u32_t)svaddv_u32(svptrue_b32(), acc_u32x);
 }
@@ -128,11 +127,13 @@ NK_PUBLIC void nk_dots_pack_u1_smebi32(nk_u1x8_t const *b, nk_size_t row_count,
     nk_size_t const tile_dim = nk_smebi32_tile_dim_();        // 16 rows per tile
     nk_size_t const depth_tile_size = nk_smebi32_tile_dim_(); // 16 u32 per depth tile
     nk_size_t const tile_elements = tile_dim * depth_tile_size;
-    nk_size_t const depth_in_bytes = nk_size_divide_round_up_(depth_bits, NK_BITS_PER_BYTE);
+    nk_size_t const depth_bytes = depth_bits / 8;
 
-    nk_size_t const depth_u32_total = nk_size_divide_round_up_(depth_bits, 32);
+    // BMOPA processes binary data in 32-bit words: each svbmopa_za32_u32_m step
+    // handles one u32 (32 bits) across all row×column pairs simultaneously.
+    nk_size_t const depth_words = nk_size_divide_round_up_(depth_bits, 32);
     nk_size_t const row_tile_count = nk_size_divide_round_up_(row_count, tile_dim);
-    nk_size_t const depth_tile_count = nk_size_divide_round_up_(depth_u32_total, depth_tile_size);
+    nk_size_t const depth_tile_count = nk_size_divide_round_up_(depth_words, depth_tile_size);
     nk_size_t const total_tiles = row_tile_count * depth_tile_count;
     nk_size_t const data_size = total_tiles * tile_elements * sizeof(nk_u32_t);
 
@@ -160,18 +161,24 @@ NK_PUBLIC void nk_dots_pack_u1_smebi32(nk_u1x8_t const *b, nk_size_t row_count,
             nk_size_t const src_u32_start = depth_tile * depth_tile_size;
             nk_size_t const rows_to_pack = (src_row_start + tile_dim <= row_count) ? tile_dim
                                                                                    : (row_count - src_row_start);
-            nk_size_t const u32s_to_pack = (src_u32_start + depth_tile_size <= depth_u32_total)
+            nk_size_t const u32s_to_pack = (src_u32_start + depth_tile_size <= depth_words)
                                                ? depth_tile_size
-                                               : (depth_u32_total > src_u32_start ? depth_u32_total - src_u32_start
-                                                                                  : 0);
+                                               : (depth_words > src_u32_start ? depth_words - src_u32_start : 0);
 
             // Column-major packing: tile_output[col * tile_dim + row]
+            // Copy byte-by-byte for the last u32 to avoid garbage bits when depth_bits % 32 != 0
+            nk_size_t const tail_bytes = depth_bytes % 4;
+            nk_size_t const last_col = u32s_to_pack > 0 ? u32s_to_pack - 1 : 0;
+            nk_size_t const is_last_depth_tile = (src_u32_start + u32s_to_pack >= depth_words);
             for (nk_size_t row = 0; row < rows_to_pack; row++) {
                 nk_u32_t const *src_row = (nk_u32_t const *)((char const *)b +
                                                              (src_row_start + row) * b_stride_in_bytes);
                 for (nk_size_t col = 0; col < u32s_to_pack; col++) {
                     nk_size_t const dst_idx = col * tile_dim + row; // Column-major!
-                    tile_output[dst_idx] = src_row[src_u32_start + col];
+                    if (tail_bytes && is_last_depth_tile && col == last_col) {
+                        nk_copy_bytes_(&tile_output[dst_idx], &src_row[src_u32_start + col], tail_bytes);
+                    }
+                    else { tile_output[dst_idx] = src_row[src_u32_start + col]; }
                 }
             }
         }
@@ -182,7 +189,7 @@ NK_PUBLIC void nk_dots_pack_u1_smebi32(nk_u1x8_t const *b, nk_size_t row_count,
         nk_u1x8_t const *src_row = (nk_u1x8_t const *)((char const *)b + row * b_stride_in_bytes);
         {
             nk_u64_t nk_local_sum_, nk_local_sumsq_;
-            nk_reduce_moments_u1(src_row, depth_in_bytes * 8, sizeof(nk_u1x8_t), &nk_local_sum_, &nk_local_sumsq_);
+            nk_reduce_moments_u1(src_row, depth_bytes * 8, sizeof(nk_u1x8_t), &nk_local_sum_, &nk_local_sumsq_);
             norms_ptr[row] = (nk_u32_t)nk_local_sum_;
         }
     }
@@ -207,19 +214,24 @@ __arm_locally_streaming __arm_new("za") static void nk_hammings_packed_u1_smebi3
     nk_size_t const tile_dim = svcntw();        // 16 for 512-bit SVL
     nk_size_t const depth_tile_size = svcntw(); // 16 u32 per depth tile
     nk_size_t const tile_elements = tile_dim * depth_tile_size;
-    nk_size_t const depth_u32_total = nk_size_divide_round_up_(depth_bits, 32);
+    // BMOPA processes binary data in 32-bit words: each svbmopa_za32_u32_m step
+    // handles one u32 (32 bits) across all row×column pairs simultaneously.
+    nk_size_t const depth_words = nk_size_divide_round_up_(depth_bits, 32);
+    nk_size_t const depth_bytes = depth_bits / 8;
 
     nk_u32_t const *b_tiles = (nk_u32_t const *)((char const *)b_packed + sizeof(nk_sets_smebi32_packed_header_t));
 
-    svbool_t const predicate_all_u32x = svptrue_b32();
-    svuint32_t const depth_u32x = svdup_u32((nk_u32_t)depth_bits);
+    svbool_t const predicate_all_b32x = svptrue_b32();
+    // Use padded depth (depth_words * 32) for BMOPA: zero-padded bits always match in XNOR,
+    // so the effective depth for the matching→hamming conversion is the rounded-up bit count.
+    svuint32_t const depth_u32x = svdup_u32((nk_u32_t)(depth_words * 32));
     nk_size_t const row_tile_count_a = nk_size_divide_round_up_(row_count_a, tile_dim);
 
     for (nk_size_t row_tile_a = 0; row_tile_a < row_tile_count_a; row_tile_a++) {
         nk_size_t const row_start_a = row_tile_a * tile_dim;
         nk_size_t const rows_a_remaining = (row_start_a + tile_dim <= row_count_a) ? tile_dim
                                                                                    : (row_count_a - row_start_a);
-        svbool_t const row_predicate_u32x = svwhilelt_b32_u64(0u, rows_a_remaining);
+        svbool_t const row_predicate_b32x = svwhilelt_b32_u64(0u, rows_a_remaining);
 
         // Fast path: 3 B column tiles using ZA1-ZA3 (ZA0.S = staging)
         nk_size_t row_tile_b = 0;
@@ -228,22 +240,23 @@ __arm_locally_streaming __arm_new("za") static void nk_hammings_packed_u1_smebi3
 
             for (nk_size_t d_tile = 0; d_tile < depth_tile_count; d_tile++) {
                 nk_size_t const d_start_u32 = d_tile * depth_tile_size;
-                nk_size_t const u32s_this_tile = (d_start_u32 + depth_tile_size <= depth_u32_total)
+                nk_size_t const u32s_this_tile = (d_start_u32 + depth_tile_size <= depth_words)
                                                      ? depth_tile_size
-                                                     : (depth_u32_total > d_start_u32 ? depth_u32_total - d_start_u32
-                                                                                      : 0);
+                                                     : (depth_words > d_start_u32 ? depth_words - d_start_u32 : 0);
                 if (u32s_this_tile == 0) break;
 
                 svzero_mask_za(nk_sme_zero_za32_tile_0_);
 
-                svbool_t const batch_predicate_u32x = svwhilelt_b32_u64(0u, u32s_this_tile);
+                svbool_t const batch_predicate_b32x = svwhilelt_b32_u64(0u, u32s_this_tile);
+
+                svbool_t const depth_predicate_b8x = svwhilelt_b8_u64(d_start_u32 * 4, depth_bytes);
 
-                // Load A rows into ZA0.S horizontally as u32 words
+                // Load A rows into ZA0.S, byte-predicated to zero garbage bits
                 for (nk_size_t row_in_tile = 0; row_in_tile < rows_a_remaining; row_in_tile++) {
-                    nk_u32_t const *a_row_u32 = (nk_u32_t const *)((char const *)a +
-                                                                   (row_start_a + row_in_tile) * a_stride_in_bytes) +
-                                                d_start_u32;
-                    svld1_hor_za32(0, row_in_tile, batch_predicate_u32x, a_row_u32);
+                    nk_u8_t const *a_row = (nk_u8_t const *)a + (row_start_a + row_in_tile) * a_stride_in_bytes +
+                                           d_start_u32 * 4;
+                    svuint8_t row_u8x = svld1_u8(depth_predicate_b8x, a_row);
+                    svwrite_hor_za32_u32_m(0, row_in_tile, batch_predicate_b32x, svreinterpret_u32_u8(row_u8x));
                 }
 
                 // B tile pointers for 3 column tiles
@@ -253,14 +266,14 @@ __arm_locally_streaming __arm_new("za") static void nk_hammings_packed_u1_smebi3
 
                 // Vertical read + BMOPA for each depth step
                 for (nk_size_t step = 0; step < u32s_this_tile; step++) {
-                    svuint32_t a_column_u32x = svread_ver_za32_u32_m(svdup_u32(0), row_predicate_u32x, 0, step);
-
-                    svbmopa_za32_u32_m(1, row_predicate_u32x, predicate_all_u32x, a_column_u32x,
-                                       svld1_u32(predicate_all_u32x, b_tile0 + step * tile_dim));
-                    svbmopa_za32_u32_m(2, row_predicate_u32x, predicate_all_u32x, a_column_u32x,
-                                       svld1_u32(predicate_all_u32x, b_tile1 + step * tile_dim));
-                    svbmopa_za32_u32_m(3, row_predicate_u32x, predicate_all_u32x, a_column_u32x,
-                                       svld1_u32(predicate_all_u32x, b_tile2 + step * tile_dim));
+                    svuint32_t a_column_u32x = svread_ver_za32_u32_m(svdup_u32(0), row_predicate_b32x, 0, step);
+
+                    svbmopa_za32_u32_m(1, row_predicate_b32x, predicate_all_b32x, a_column_u32x,
+                                       svld1_u32(predicate_all_b32x, b_tile0 + step * tile_dim));
+                    svbmopa_za32_u32_m(2, row_predicate_b32x, predicate_all_b32x, a_column_u32x,
+                                       svld1_u32(predicate_all_b32x, b_tile1 + step * tile_dim));
+                    svbmopa_za32_u32_m(3, row_predicate_b32x, predicate_all_b32x, a_column_u32x,
+                                       svld1_u32(predicate_all_b32x, b_tile2 + step * tile_dim));
                 }
             }
 
@@ -268,16 +281,16 @@ __arm_locally_streaming __arm_new("za") static void nk_hammings_packed_u1_smebi3
             for (nk_size_t row = 0; row < rows_a_remaining; row++) {
                 nk_u32_t *c_row = (nk_u32_t *)((char *)c + (row_start_a + row) * c_stride_in_bytes);
 
-                svuint32_t za1_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_u32x, 1, row);
-                svuint32_t za2_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_u32x, 2, row);
-                svuint32_t za3_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_u32x, 3, row);
+                svuint32_t za1_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_b32x, 1, row);
+                svuint32_t za2_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_b32x, 2, row);
+                svuint32_t za3_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_b32x, 3, row);
 
-                svst1_u32(predicate_all_u32x, c_row + (row_tile_b + 0) * tile_dim,
-                          svsub_u32_x(predicate_all_u32x, depth_u32x, za1_u32x));
-                svst1_u32(predicate_all_u32x, c_row + (row_tile_b + 1) * tile_dim,
-                          svsub_u32_x(predicate_all_u32x, depth_u32x, za2_u32x));
-                svst1_u32(predicate_all_u32x, c_row + (row_tile_b + 2) * tile_dim,
-                          svsub_u32_x(predicate_all_u32x, depth_u32x, za3_u32x));
+                svst1_u32(predicate_all_b32x, c_row + (row_tile_b + 0) * tile_dim,
+                          svsub_u32_x(predicate_all_b32x, depth_u32x, za1_u32x));
+                svst1_u32(predicate_all_b32x, c_row + (row_tile_b + 1) * tile_dim,
+                          svsub_u32_x(predicate_all_b32x, depth_u32x, za2_u32x));
+                svst1_u32(predicate_all_b32x, c_row + (row_tile_b + 2) * tile_dim,
+                          svsub_u32_x(predicate_all_b32x, depth_u32x, za3_u32x));
             }
         }
 
@@ -286,46 +299,46 @@ __arm_locally_streaming __arm_new("za") static void nk_hammings_packed_u1_smebi3
             nk_size_t const row_start_b = row_tile_b * tile_dim;
             nk_size_t const rows_b_remaining = (row_start_b + tile_dim <= row_count_b) ? tile_dim
                                                                                        : (row_count_b - row_start_b);
-            svbool_t const column_predicate_u32x = svwhilelt_b32_u64(0u, rows_b_remaining);
+            svbool_t const column_predicate_b32x = svwhilelt_b32_u64(0u, rows_b_remaining);
 
             svzero_mask_za(nk_sme_zero_za32_tile_1_);
 
             for (nk_size_t d_tile = 0; d_tile < depth_tile_count; d_tile++) {
                 nk_size_t const d_start_u32 = d_tile * depth_tile_size;
-                nk_size_t const u32s_this_tile = (d_start_u32 + depth_tile_size <= depth_u32_total)
+                nk_size_t const u32s_this_tile = (d_start_u32 + depth_tile_size <= depth_words)
                                                      ? depth_tile_size
-                                                     : (depth_u32_total > d_start_u32 ? depth_u32_total - d_start_u32
-                                                                                      : 0);
+                                                     : (depth_words > d_start_u32 ? depth_words - d_start_u32 : 0);
                 if (u32s_this_tile == 0) break;
 
                 svzero_mask_za(nk_sme_zero_za32_tile_0_);
 
-                svbool_t const batch_predicate_u32x = svwhilelt_b32_u64(0u, u32s_this_tile);
+                svbool_t const batch_predicate_b32x = svwhilelt_b32_u64(0u, u32s_this_tile);
 
                 // Load A rows into ZA0.S horizontally
+                svbool_t const depth_predicate_b8x = svwhilelt_b8_u64(d_start_u32 * 4, depth_bytes);
                 for (nk_size_t row_in_tile = 0; row_in_tile < rows_a_remaining; row_in_tile++) {
-                    nk_u32_t const *a_row_u32 = (nk_u32_t const *)((char const *)a +
-                                                                   (row_start_a + row_in_tile) * a_stride_in_bytes) +
-                                                d_start_u32;
-                    svld1_hor_za32(0, row_in_tile, batch_predicate_u32x, a_row_u32);
+                    nk_u8_t const *a_row = (nk_u8_t const *)a + (row_start_a + row_in_tile) * a_stride_in_bytes +
+                                           d_start_u32 * 4;
+                    svuint8_t row_u8x = svld1_u8(depth_predicate_b8x, a_row);
+                    svwrite_hor_za32_u32_m(0, row_in_tile, batch_predicate_b32x, svreinterpret_u32_u8(row_u8x));
                 }
 
                 nk_u32_t const *b_tile = b_tiles + (row_tile_b * depth_tile_count + d_tile) * tile_elements;
 
                 // Vertical read + BMOPA
                 for (nk_size_t step = 0; step < u32s_this_tile; step++) {
-                    svuint32_t a_column_u32x = svread_ver_za32_u32_m(svdup_u32(0), row_predicate_u32x, 0, step);
-                    svuint32_t b_u32x = svld1_u32(predicate_all_u32x, b_tile + step * tile_dim);
-                    svbmopa_za32_u32_m(1, row_predicate_u32x, column_predicate_u32x, a_column_u32x, b_u32x);
+                    svuint32_t a_column_u32x = svread_ver_za32_u32_m(svdup_u32(0), row_predicate_b32x, 0, step);
+                    svuint32_t b_u32x = svld1_u32(predicate_all_b32x, b_tile + step * tile_dim);
+                    svbmopa_za32_u32_m(1, row_predicate_b32x, column_predicate_b32x, a_column_u32x, b_u32x);
                 }
             }
 
             // Extract from ZA1: Hamming = depth_bits - matching_bits
             for (nk_size_t row = 0; row < rows_a_remaining; row++) {
-                svuint32_t za1_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_u32x, 1, row);
-                svuint32_t hamming_u32x = svsub_u32_x(predicate_all_u32x, depth_u32x, za1_u32x);
+                svuint32_t za1_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_b32x, 1, row);
+                svuint32_t hamming_u32x = svsub_u32_x(predicate_all_b32x, depth_u32x, za1_u32x);
                 nk_u32_t *c_row = (nk_u32_t *)((char *)c + (row_start_a + row) * c_stride_in_bytes);
-                svst1_u32(column_predicate_u32x, c_row + row_start_b, hamming_u32x);
+                svst1_u32(column_predicate_b32x, c_row + row_start_b, hamming_u32x);
             }
         }
     }
@@ -345,30 +358,37 @@ NK_PUBLIC void nk_hammings_packed_u1_smebi32(nk_u1x8_t const *a, void const *b_p
  *  Mirrors the unpacked kernel nk_hammings_packed_u1_smebi32_streaming_ pattern.
  */
 __arm_locally_streaming __arm_new("za") static void nk_hammings_symmetric_u1_smebi32_streaming_(
-    nk_u1x8_t const *vectors, nk_size_t n_vectors, nk_size_t depth_bits, nk_size_t stride, nk_u32_t *result,
-    nk_size_t result_stride, nk_size_t row_start, nk_size_t row_count) {
+    nk_u1x8_t const *vectors, nk_size_t vectors_count, nk_size_t depth_bits, nk_size_t stride_in_bytes,
+    nk_u32_t *result, nk_size_t result_stride_in_bytes, nk_size_t row_start, nk_size_t row_count) {
 
     nk_size_t const tile_dim = svcntw();        // 16 for 512-bit SVL
     nk_size_t const depth_tile_size = svcntw(); // 16 u32 per depth tile
-    nk_size_t const depth_u32_total = nk_size_divide_round_up_(depth_bits, 32);
-    nk_size_t const depth_tile_count = nk_size_divide_round_up_(depth_u32_total, depth_tile_size);
+    // BMOPA processes binary data in 32-bit words: each svbmopa_za32_u32_m step
+    // handles one u32 (32 bits) across all row×column pairs simultaneously.
+    nk_size_t const depth_words = nk_size_divide_round_up_(depth_bits, 32);
+    nk_size_t const depth_bytes = depth_bits / 8;
+    nk_size_t const depth_tile_count = nk_size_divide_round_up_(depth_words, depth_tile_size);
 
-    svbool_t const predicate_all_u32x = svptrue_b32();
-    svuint32_t const depth_u32x = svdup_u32((nk_u32_t)depth_bits);
+    svbool_t const predicate_all_b32x = svptrue_b32();
+    // Use padded depth (depth_words * 32) for BMOPA: zero-padded bits always match in XNOR,
+    // so the effective depth for the matching→hamming conversion is the rounded-up bit count.
+    svuint32_t const depth_u32x = svdup_u32((nk_u32_t)(depth_words * 32));
 
     NK_ALIGN64 nk_u32_t a_buffer[16][16]; // Stack buffer for A column save
 
     nk_size_t const row_end = row_start + row_count;
-    nk_size_t const column_tile_count = nk_size_divide_round_up_(n_vectors, tile_dim);
+    nk_size_t const column_tile_count = nk_size_divide_round_up_(vectors_count, tile_dim);
 
-    for (nk_size_t row_tile_start = row_start; row_tile_start < row_end && row_tile_start < n_vectors;
+    for (nk_size_t row_tile_start = row_start; row_tile_start < row_end && row_tile_start < vectors_count;
          row_tile_start += tile_dim) {
         nk_size_t const rows_remaining = (row_tile_start + tile_dim <= row_end) ? tile_dim : (row_end - row_tile_start);
-        nk_size_t const rows_clamped = (row_tile_start + rows_remaining <= n_vectors) ? rows_remaining
-                                                                                      : (n_vectors - row_tile_start);
-        svbool_t const row_predicate_u32x = svwhilelt_b32_u64(0u, rows_clamped);
+        nk_size_t const rows_clamped = (row_tile_start + rows_remaining <= vectors_count)
+                                           ? rows_remaining
+                                           : (vectors_count - row_tile_start);
+        svbool_t const row_predicate_b32x = svwhilelt_b32_u64(0u, rows_clamped);
 
-        nk_size_t column_tile_index = 0;
+        // Upper triangle: start from this row tile's column
+        nk_size_t column_tile_index = row_tile_start / tile_dim;
 
         // Fast path: 3 column tiles using ZA1-ZA3 (ZA0 = staging)
         for (; column_tile_index + 3 <= column_tile_count; column_tile_index += 3) {
@@ -376,162 +396,164 @@ __arm_locally_streaming __arm_new("za") static void nk_hammings_symmetric_u1_sme
 
             for (nk_size_t d_tile = 0; d_tile < depth_tile_count; d_tile++) {
                 nk_size_t const d_start_u32 = d_tile * depth_tile_size;
-                nk_size_t const u32s_this_tile = (d_start_u32 + depth_tile_size <= depth_u32_total)
+                nk_size_t const u32s_this_tile = (d_start_u32 + depth_tile_size <= depth_words)
                                                      ? depth_tile_size
-                                                     : (depth_u32_total > d_start_u32 ? depth_u32_total - d_start_u32
-                                                                                      : 0);
+                                                     : (depth_words > d_start_u32 ? depth_words - d_start_u32 : 0);
                 if (u32s_this_tile == 0) break;
 
                 // Load A rows into ZA0 horizontally
                 svzero_mask_za(nk_sme_zero_za32_tile_0_);
-                svbool_t const batch_predicate_u32x = svwhilelt_b32_u64(0u, u32s_this_tile);
+                svbool_t const batch_predicate_b32x = svwhilelt_b32_u64(0u, u32s_this_tile);
 
+                svbool_t const depth_predicate_b8x = svwhilelt_b8_u64(d_start_u32 * 4, depth_bytes);
                 for (nk_size_t row_in_tile = 0; row_in_tile < rows_clamped; row_in_tile++) {
-                    nk_u32_t const *a_row_u32 = (nk_u32_t const *)((char const *)vectors +
-                                                                   (row_tile_start + row_in_tile) * stride) +
-                                                d_start_u32;
-                    svld1_hor_za32(0, row_in_tile, batch_predicate_u32x, a_row_u32);
+                    nk_u8_t const *a_row = (nk_u8_t const *)vectors + (row_tile_start + row_in_tile) * stride_in_bytes +
+                                           d_start_u32 * 4;
+                    svuint8_t row_u8x = svld1_u8(depth_predicate_b8x, a_row);
+                    svwrite_hor_za32_u32_m(0, row_in_tile, batch_predicate_b32x, svreinterpret_u32_u8(row_u8x));
                 }
 
                 // Save A columns from ZA0 to stack buffer
                 for (nk_size_t s = 0; s < u32s_this_tile; s++)
-                    svst1_u32(predicate_all_u32x, a_buffer[s],
-                              svread_ver_za32_u32_m(svdup_u32(0), row_predicate_u32x, 0, s));
+                    svst1_u32(predicate_all_b32x, a_buffer[s],
+                              svread_ver_za32_u32_m(svdup_u32(0), row_predicate_b32x, 0, s));
 
                 // B column tile 0
                 svzero_mask_za(nk_sme_zero_za32_tile_0_);
                 for (nk_size_t col = 0; col < tile_dim; col++) {
                     nk_size_t const col_abs = (column_tile_index + 0) * tile_dim + col;
-                    if (col_abs < n_vectors) {
-                        nk_u32_t const *b_row = (nk_u32_t const *)((char const *)vectors + col_abs * stride) +
-                                                d_start_u32;
-                        svld1_hor_za32(0, col, batch_predicate_u32x, b_row);
+                    if (col_abs < vectors_count) {
+                        nk_u8_t const *b_row = (nk_u8_t const *)vectors + col_abs * stride_in_bytes + d_start_u32 * 4;
+                        svuint8_t col_u8x = svld1_u8(depth_predicate_b8x, b_row);
+                        svwrite_hor_za32_u32_m(0, col, batch_predicate_b32x, svreinterpret_u32_u8(col_u8x));
                     }
                 }
                 for (nk_size_t step = 0; step < u32s_this_tile; step++) {
-                    svuint32_t a_u32x = svld1_u32(predicate_all_u32x, a_buffer[step]);
-                    svuint32_t b_u32x = svread_ver_za32_u32_m(svdup_u32(0), predicate_all_u32x, 0, step);
-                    svbmopa_za32_u32_m(1, row_predicate_u32x, predicate_all_u32x, a_u32x, b_u32x);
+                    svuint32_t a_u32x = svld1_u32(predicate_all_b32x, a_buffer[step]);
+                    svuint32_t b_u32x = svread_ver_za32_u32_m(svdup_u32(0), predicate_all_b32x, 0, step);
+                    svbmopa_za32_u32_m(1, row_predicate_b32x, predicate_all_b32x, a_u32x, b_u32x);
                 }
 
                 // B column tile 1
                 svzero_mask_za(nk_sme_zero_za32_tile_0_);
                 for (nk_size_t col = 0; col < tile_dim; col++) {
                     nk_size_t const col_abs = (column_tile_index + 1) * tile_dim + col;
-                    if (col_abs < n_vectors) {
-                        nk_u32_t const *b_row = (nk_u32_t const *)((char const *)vectors + col_abs * stride) +
-                                                d_start_u32;
-                        svld1_hor_za32(0, col, batch_predicate_u32x, b_row);
+                    if (col_abs < vectors_count) {
+                        nk_u8_t const *b_row = (nk_u8_t const *)vectors + col_abs * stride_in_bytes + d_start_u32 * 4;
+                        svuint8_t col_u8x = svld1_u8(depth_predicate_b8x, b_row);
+                        svwrite_hor_za32_u32_m(0, col, batch_predicate_b32x, svreinterpret_u32_u8(col_u8x));
                     }
                 }
                 for (nk_size_t step = 0; step < u32s_this_tile; step++) {
-                    svuint32_t a_u32x = svld1_u32(predicate_all_u32x, a_buffer[step]);
-                    svuint32_t b_u32x = svread_ver_za32_u32_m(svdup_u32(0), predicate_all_u32x, 0, step);
-                    svbmopa_za32_u32_m(2, row_predicate_u32x, predicate_all_u32x, a_u32x, b_u32x);
+                    svuint32_t a_u32x = svld1_u32(predicate_all_b32x, a_buffer[step]);
+                    svuint32_t b_u32x = svread_ver_za32_u32_m(svdup_u32(0), predicate_all_b32x, 0, step);
+                    svbmopa_za32_u32_m(2, row_predicate_b32x, predicate_all_b32x, a_u32x, b_u32x);
                 }
 
                 // B column tile 2
                 svzero_mask_za(nk_sme_zero_za32_tile_0_);
                 for (nk_size_t col = 0; col < tile_dim; col++) {
                     nk_size_t const col_abs = (column_tile_index + 2) * tile_dim + col;
-                    if (col_abs < n_vectors) {
-                        nk_u32_t const *b_row = (nk_u32_t const *)((char const *)vectors + col_abs * stride) +
-                                                d_start_u32;
-                        svld1_hor_za32(0, col, batch_predicate_u32x, b_row);
+                    if (col_abs < vectors_count) {
+                        nk_u8_t const *b_row = (nk_u8_t const *)vectors + col_abs * stride_in_bytes + d_start_u32 * 4;
+                        svuint8_t col_u8x = svld1_u8(depth_predicate_b8x, b_row);
+                        svwrite_hor_za32_u32_m(0, col, batch_predicate_b32x, svreinterpret_u32_u8(col_u8x));
                     }
                 }
                 for (nk_size_t step = 0; step < u32s_this_tile; step++) {
-                    svuint32_t a_u32x = svld1_u32(predicate_all_u32x, a_buffer[step]);
-                    svuint32_t b_u32x = svread_ver_za32_u32_m(svdup_u32(0), predicate_all_u32x, 0, step);
-                    svbmopa_za32_u32_m(3, row_predicate_u32x, predicate_all_u32x, a_u32x, b_u32x);
+                    svuint32_t a_u32x = svld1_u32(predicate_all_b32x, a_buffer[step]);
+                    svuint32_t b_u32x = svread_ver_za32_u32_m(svdup_u32(0), predicate_all_b32x, 0, step);
+                    svbmopa_za32_u32_m(3, row_predicate_b32x, predicate_all_b32x, a_u32x, b_u32x);
                 }
             }
 
             // Extract ZA1-3: hamming = depth_bits - ZA[i][j]
             for (nk_size_t row = 0; row < rows_clamped; row++) {
-                nk_u32_t *c_row = (nk_u32_t *)((char *)result + (row_tile_start + row) * result_stride);
-
-                svuint32_t za1_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_u32x, 1, row);
-                svuint32_t za2_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_u32x, 2, row);
-                svuint32_t za3_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_u32x, 3, row);
-
-                svst1_u32(predicate_all_u32x, c_row + (column_tile_index + 0) * tile_dim,
-                          svsub_u32_x(predicate_all_u32x, depth_u32x, za1_u32x));
-                svst1_u32(predicate_all_u32x, c_row + (column_tile_index + 1) * tile_dim,
-                          svsub_u32_x(predicate_all_u32x, depth_u32x, za2_u32x));
-                svst1_u32(predicate_all_u32x, c_row + (column_tile_index + 2) * tile_dim,
-                          svsub_u32_x(predicate_all_u32x, depth_u32x, za3_u32x));
+                nk_u32_t *c_row = (nk_u32_t *)((char *)result + (row_tile_start + row) * result_stride_in_bytes);
+
+                svuint32_t za1_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_b32x, 1, row);
+                svuint32_t za2_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_b32x, 2, row);
+                svuint32_t za3_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_b32x, 3, row);
+
+                svst1_u32(predicate_all_b32x, c_row + (column_tile_index + 0) * tile_dim,
+                          svsub_u32_x(predicate_all_b32x, depth_u32x, za1_u32x));
+                svst1_u32(predicate_all_b32x, c_row + (column_tile_index + 1) * tile_dim,
+                          svsub_u32_x(predicate_all_b32x, depth_u32x, za2_u32x));
+                svst1_u32(predicate_all_b32x, c_row + (column_tile_index + 2) * tile_dim,
+                          svsub_u32_x(predicate_all_b32x, depth_u32x, za3_u32x));
             }
         }
 
         // Remainder: 1 column tile at a time using ZA1
         for (; column_tile_index < column_tile_count; column_tile_index++) {
             nk_size_t const col_tile_start = column_tile_index * tile_dim;
-            nk_size_t const cols_remaining = (col_tile_start + tile_dim <= n_vectors) ? tile_dim
-                                                                                      : (n_vectors - col_tile_start);
-            svbool_t const column_predicate_u32x = svwhilelt_b32_u64(0u, cols_remaining);
+            nk_size_t const cols_remaining = (col_tile_start + tile_dim <= vectors_count)
+                                                 ? tile_dim
+                                                 : (vectors_count - col_tile_start);
+            svbool_t const column_predicate_b32x = svwhilelt_b32_u64(0u, cols_remaining);
 
             svzero_mask_za(nk_sme_zero_za32_tile_1_);
 
             for (nk_size_t d_tile = 0; d_tile < depth_tile_count; d_tile++) {
                 nk_size_t const d_start_u32 = d_tile * depth_tile_size;
-                nk_size_t const u32s_this_tile = (d_start_u32 + depth_tile_size <= depth_u32_total)
+                nk_size_t const u32s_this_tile = (d_start_u32 + depth_tile_size <= depth_words)
                                                      ? depth_tile_size
-                                                     : (depth_u32_total > d_start_u32 ? depth_u32_total - d_start_u32
-                                                                                      : 0);
+                                                     : (depth_words > d_start_u32 ? depth_words - d_start_u32 : 0);
                 if (u32s_this_tile == 0) break;
 
                 svzero_mask_za(nk_sme_zero_za32_tile_0_);
-                svbool_t const batch_predicate_u32x = svwhilelt_b32_u64(0u, u32s_this_tile);
+                svbool_t const batch_predicate_b32x = svwhilelt_b32_u64(0u, u32s_this_tile);
 
                 // Load A rows into ZA0 horizontally
+                svbool_t const depth_predicate_b8x = svwhilelt_b8_u64(d_start_u32 * 4, depth_bytes);
                 for (nk_size_t row_in_tile = 0; row_in_tile < rows_clamped; row_in_tile++) {
-                    nk_u32_t const *a_row_u32 = (nk_u32_t const *)((char const *)vectors +
-                                                                   (row_tile_start + row_in_tile) * stride) +
-                                                d_start_u32;
-                    svld1_hor_za32(0, row_in_tile, batch_predicate_u32x, a_row_u32);
+                    nk_u8_t const *a_row = (nk_u8_t const *)vectors + (row_tile_start + row_in_tile) * stride_in_bytes +
+                                           d_start_u32 * 4;
+                    svuint8_t row_u8x = svld1_u8(depth_predicate_b8x, a_row);
+                    svwrite_hor_za32_u32_m(0, row_in_tile, batch_predicate_b32x, svreinterpret_u32_u8(row_u8x));
                 }
 
                 // Save A columns from ZA0 to stack buffer
                 for (nk_size_t s = 0; s < u32s_this_tile; s++)
-                    svst1_u32(predicate_all_u32x, a_buffer[s],
-                              svread_ver_za32_u32_m(svdup_u32(0), row_predicate_u32x, 0, s));
+                    svst1_u32(predicate_all_b32x, a_buffer[s],
+                              svread_ver_za32_u32_m(svdup_u32(0), row_predicate_b32x, 0, s));
 
                 // Load B column tile into ZA0
                 svzero_mask_za(nk_sme_zero_za32_tile_0_);
                 for (nk_size_t col = 0; col < tile_dim; col++) {
                     nk_size_t const col_abs = col_tile_start + col;
-                    if (col_abs < n_vectors) {
-                        nk_u32_t const *b_row = (nk_u32_t const *)((char const *)vectors + col_abs * stride) +
-                                                d_start_u32;
-                        svld1_hor_za32(0, col, batch_predicate_u32x, b_row);
+                    if (col_abs < vectors_count) {
+                        nk_u8_t const *b_row = (nk_u8_t const *)vectors + col_abs * stride_in_bytes + d_start_u32 * 4;
+                        svuint8_t col_u8x = svld1_u8(depth_predicate_b8x, b_row);
+                        svwrite_hor_za32_u32_m(0, col, batch_predicate_b32x, svreinterpret_u32_u8(col_u8x));
                     }
                 }
                 for (nk_size_t step = 0; step < u32s_this_tile; step++) {
-                    svuint32_t a_u32x = svld1_u32(predicate_all_u32x, a_buffer[step]);
-                    svuint32_t b_u32x = svread_ver_za32_u32_m(svdup_u32(0), column_predicate_u32x, 0, step);
-                    svbmopa_za32_u32_m(1, row_predicate_u32x, column_predicate_u32x, a_u32x, b_u32x);
+                    svuint32_t a_u32x = svld1_u32(predicate_all_b32x, a_buffer[step]);
+                    svuint32_t b_u32x = svread_ver_za32_u32_m(svdup_u32(0), column_predicate_b32x, 0, step);
+                    svbmopa_za32_u32_m(1, row_predicate_b32x, column_predicate_b32x, a_u32x, b_u32x);
                 }
             }
 
             for (nk_size_t row = 0; row < rows_clamped; row++) {
-                svuint32_t za1_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_u32x, 1, row);
-                svuint32_t hamming_u32x = svsub_u32_x(predicate_all_u32x, depth_u32x, za1_u32x);
-                nk_u32_t *c_row = (nk_u32_t *)((char *)result + (row_tile_start + row) * result_stride);
-                svst1_u32(column_predicate_u32x, c_row + col_tile_start, hamming_u32x);
+                svuint32_t za1_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_b32x, 1, row);
+                svuint32_t hamming_u32x = svsub_u32_x(predicate_all_b32x, depth_u32x, za1_u32x);
+                nk_u32_t *c_row = (nk_u32_t *)((char *)result + (row_tile_start + row) * result_stride_in_bytes);
+                svst1_u32(column_predicate_b32x, c_row + col_tile_start, hamming_u32x);
             }
         }
     }
 }
 
-NK_PUBLIC void nk_hammings_symmetric_u1_smebi32(nk_u1x8_t const *vectors, nk_size_t n_vectors, nk_size_t depth_bits,
-                                                nk_size_t stride, nk_u32_t *result, nk_size_t result_stride,
-                                                nk_size_t row_start, nk_size_t row_count) {
-    nk_hammings_symmetric_u1_smebi32_streaming_(vectors, n_vectors, depth_bits, stride, result, result_stride,
-                                                row_start, row_count);
+NK_PUBLIC void nk_hammings_symmetric_u1_smebi32(nk_u1x8_t const *vectors, nk_size_t vectors_count, nk_size_t depth_bits,
+                                                nk_size_t stride_in_bytes, nk_u32_t *result,
+                                                nk_size_t result_stride_in_bytes, nk_size_t row_start,
+                                                nk_size_t row_count) {
+    nk_hammings_symmetric_u1_smebi32_streaming_(vectors, vectors_count, depth_bits, stride_in_bytes, result,
+                                                result_stride_in_bytes, row_start, row_count);
 }
 
-#pragma endregion // Hamming Distance
+#pragma endregion Hamming Distance
 
 /*
  *  Jaccard distance via BMOPA matching counts + algebraic normalization.
@@ -570,31 +592,33 @@ __arm_locally_streaming __arm_new("za") static void nk_jaccards_packed_u1_smebi3
     nk_size_t const tile_dim = svcntw();        // 16 for 512-bit SVL
     nk_size_t const depth_tile_size = svcntw(); // 16 u32 per depth tile
     nk_size_t const tile_elements = tile_dim * depth_tile_size;
-    nk_size_t const depth_u32_total = nk_size_divide_round_up_(depth_bits, 32);
+    // BMOPA processes binary data in 32-bit words: each svbmopa_za32_u32_m step
+    // handles one u32 (32 bits) across all row×column pairs simultaneously.
+    nk_size_t const depth_words = nk_size_divide_round_up_(depth_bits, 32);
+    nk_size_t const depth_bytes = depth_bits / 8;
 
     nk_u32_t const *b_tiles = (nk_u32_t const *)((char const *)b_packed + sizeof(nk_sets_smebi32_packed_header_t));
     nk_u32_t const *b_norms = header->norms_offset ? (nk_u32_t const *)((char const *)b_packed + header->norms_offset)
                                                    : (nk_u32_t const *)0;
 
-    svbool_t const predicate_all_f32x = svptrue_b32();
-    svfloat32_t const depth_f32x = svdup_f32((nk_f32_t)depth_bits);
+    svbool_t const predicate_all_b32x = svptrue_b32();
+    svfloat32_t const depth_f32x = svdup_f32((nk_f32_t)(depth_words * 32));
     svfloat32_t const half_f32x = svdup_f32(0.5f);
     svfloat32_t const one_f32x = svdup_f32(1.0f);
     svfloat32_t const zero_f32x = svdup_f32(0.0f);
-    nk_size_t const depth_in_bytes = nk_size_divide_round_up_(depth_bits, 8);
     nk_size_t const row_tile_count_a = nk_size_divide_round_up_(row_count_a, tile_dim);
 
     for (nk_size_t row_tile_a = 0; row_tile_a < row_tile_count_a; row_tile_a++) {
         nk_size_t const row_start_a = row_tile_a * tile_dim;
         nk_size_t const rows_a_remaining = (row_start_a + tile_dim <= row_count_a) ? tile_dim
                                                                                    : (row_count_a - row_start_a);
-        svbool_t const row_predicate_f32x = svwhilelt_b32_u64(0u, rows_a_remaining);
+        svbool_t const row_predicate_b32x = svwhilelt_b32_u64(0u, rows_a_remaining);
 
         // Compute A tile norms using streaming SVE popcount
         NK_ALIGN64 nk_f32_t a_tile_norms[16];
         for (nk_size_t r = 0; r < rows_a_remaining; r++) {
             nk_u1x8_t const *a_row = (nk_u1x8_t const *)((char const *)a + (row_start_a + r) * a_stride_in_bytes);
-            a_tile_norms[r] = (nk_f32_t)nk_sets_reduce_sumsq_u1_streaming_(a_row, depth_in_bytes);
+            a_tile_norms[r] = (nk_f32_t)nk_sets_reduce_sumsq_u1_streaming_(a_row, depth_bytes);
         }
 
         // Fast path: 3 B column tiles using ZA1-ZA3 (ZA0.S = staging)
@@ -604,22 +628,23 @@ __arm_locally_streaming __arm_new("za") static void nk_jaccards_packed_u1_smebi3
 
             for (nk_size_t d_tile = 0; d_tile < depth_tile_count; d_tile++) {
                 nk_size_t const d_start_u32 = d_tile * depth_tile_size;
-                nk_size_t const u32s_this_tile = (d_start_u32 + depth_tile_size <= depth_u32_total)
+                nk_size_t const u32s_this_tile = (d_start_u32 + depth_tile_size <= depth_words)
                                                      ? depth_tile_size
-                                                     : (depth_u32_total > d_start_u32 ? depth_u32_total - d_start_u32
-                                                                                      : 0);
+                                                     : (depth_words > d_start_u32 ? depth_words - d_start_u32 : 0);
                 if (u32s_this_tile == 0) break;
 
                 svzero_mask_za(nk_sme_zero_za32_tile_0_);
 
-                svbool_t const batch_predicate_f32x = svwhilelt_b32_u64(0u, u32s_this_tile);
+                svbool_t const batch_predicate_b32x = svwhilelt_b32_u64(0u, u32s_this_tile);
+
+                svbool_t const depth_predicate_b8x = svwhilelt_b8_u64(d_start_u32 * 4, depth_bytes);
 
-                // Load A rows into ZA0.S horizontally as u32 words
+                // Load A rows into ZA0.S, byte-predicated to zero garbage bits
                 for (nk_size_t row_in_tile = 0; row_in_tile < rows_a_remaining; row_in_tile++) {
-                    nk_u32_t const *a_row_u32 = (nk_u32_t const *)((char const *)a +
-                                                                   (row_start_a + row_in_tile) * a_stride_in_bytes) +
-                                                d_start_u32;
-                    svld1_hor_za32(0, row_in_tile, batch_predicate_f32x, a_row_u32);
+                    nk_u8_t const *a_row = (nk_u8_t const *)a + (row_start_a + row_in_tile) * a_stride_in_bytes +
+                                           d_start_u32 * 4;
+                    svuint8_t row_u8x = svld1_u8(depth_predicate_b8x, a_row);
+                    svwrite_hor_za32_u32_m(0, row_in_tile, batch_predicate_b32x, svreinterpret_u32_u8(row_u8x));
                 }
 
                 // B tile pointers for 3 column tiles
@@ -629,25 +654,25 @@ __arm_locally_streaming __arm_new("za") static void nk_jaccards_packed_u1_smebi3
 
                 // Vertical read + BMOPA for each depth step
                 for (nk_size_t step = 0; step < u32s_this_tile; step++) {
-                    svuint32_t a_column_u32x = svread_ver_za32_u32_m(svdup_u32(0), row_predicate_f32x, 0, step);
-
-                    svbmopa_za32_u32_m(1, row_predicate_f32x, predicate_all_f32x, a_column_u32x,
-                                       svld1_u32(predicate_all_f32x, b_tile0 + step * tile_dim));
-                    svbmopa_za32_u32_m(2, row_predicate_f32x, predicate_all_f32x, a_column_u32x,
-                                       svld1_u32(predicate_all_f32x, b_tile1 + step * tile_dim));
-                    svbmopa_za32_u32_m(3, row_predicate_f32x, predicate_all_f32x, a_column_u32x,
-                                       svld1_u32(predicate_all_f32x, b_tile2 + step * tile_dim));
+                    svuint32_t a_column_u32x = svread_ver_za32_u32_m(svdup_u32(0), row_predicate_b32x, 0, step);
+
+                    svbmopa_za32_u32_m(1, row_predicate_b32x, predicate_all_b32x, a_column_u32x,
+                                       svld1_u32(predicate_all_b32x, b_tile0 + step * tile_dim));
+                    svbmopa_za32_u32_m(2, row_predicate_b32x, predicate_all_b32x, a_column_u32x,
+                                       svld1_u32(predicate_all_b32x, b_tile1 + step * tile_dim));
+                    svbmopa_za32_u32_m(3, row_predicate_b32x, predicate_all_b32x, a_column_u32x,
+                                       svld1_u32(predicate_all_b32x, b_tile2 + step * tile_dim));
                 }
             }
 
             // Extract from ZA1-3: Jaccard normalization via streaming SVE
             // Hoist B norms outside row loop (same for all A rows in this tile-pair)
             svfloat32_t b_norms_0_f32x = svcvt_f32_u32_x(
-                predicate_all_f32x, svld1_u32(predicate_all_f32x, b_norms + (row_tile_b + 0) * tile_dim));
+                predicate_all_b32x, svld1_u32(predicate_all_b32x, b_norms + (row_tile_b + 0) * tile_dim));
             svfloat32_t b_norms_1_f32x = svcvt_f32_u32_x(
-                predicate_all_f32x, svld1_u32(predicate_all_f32x, b_norms + (row_tile_b + 1) * tile_dim));
+                predicate_all_b32x, svld1_u32(predicate_all_b32x, b_norms + (row_tile_b + 1) * tile_dim));
             svfloat32_t b_norms_2_f32x = svcvt_f32_u32_x(
-                predicate_all_f32x, svld1_u32(predicate_all_f32x, b_norms + (row_tile_b + 2) * tile_dim));
+                predicate_all_b32x, svld1_u32(predicate_all_b32x, b_norms + (row_tile_b + 2) * tile_dim));
 
             for (nk_size_t row = 0; row < rows_a_remaining; row++) {
                 nk_f32_t *c_row = (nk_f32_t *)((char *)c + (row_start_a + row) * c_stride_in_bytes);
@@ -655,54 +680,54 @@ __arm_locally_streaming __arm_new("za") static void nk_jaccards_packed_u1_smebi3
 
                 // ZA1
                 {
-                    svuint32_t za1_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_f32x, 1, row);
-                    svfloat32_t matching_f32x = svcvt_f32_u32_x(predicate_all_f32x, za1_u32x);
-                    svfloat32_t sum_norms_f32x = svadd_f32_x(predicate_all_f32x, norm_a_f32x, b_norms_0_f32x);
+                    svuint32_t za1_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_b32x, 1, row);
+                    svfloat32_t matching_f32x = svcvt_f32_u32_x(predicate_all_b32x, za1_u32x);
+                    svfloat32_t sum_norms_f32x = svadd_f32_x(predicate_all_b32x, norm_a_f32x, b_norms_0_f32x);
                     svfloat32_t intersection_f32x = svmul_f32_x(
-                        predicate_all_f32x,
-                        svadd_f32_x(predicate_all_f32x, svsub_f32_x(predicate_all_f32x, sum_norms_f32x, depth_f32x),
+                        predicate_all_b32x,
+                        svadd_f32_x(predicate_all_b32x, svsub_f32_x(predicate_all_b32x, sum_norms_f32x, depth_f32x),
                                     matching_f32x),
                         half_f32x);
-                    svfloat32_t union_val_f32x = svsub_f32_x(predicate_all_f32x, sum_norms_f32x, intersection_f32x);
-                    svbool_t nonzero_f32x = svcmpne_f32(predicate_all_f32x, union_val_f32x, zero_f32x);
-                    svfloat32_t ratio_f32x = svdiv_f32_x(predicate_all_f32x, intersection_f32x, union_val_f32x);
+                    svfloat32_t union_val_f32x = svsub_f32_x(predicate_all_b32x, sum_norms_f32x, intersection_f32x);
+                    svbool_t nonzero_b32x = svcmpne_f32(predicate_all_b32x, union_val_f32x, zero_f32x);
+                    svfloat32_t ratio_f32x = svdiv_f32_x(predicate_all_b32x, intersection_f32x, union_val_f32x);
                     svfloat32_t jaccard_f32x = svsel_f32(
-                        nonzero_f32x, svsub_f32_x(predicate_all_f32x, one_f32x, ratio_f32x), one_f32x);
-                    svst1_f32(predicate_all_f32x, c_row + (row_tile_b + 0) * tile_dim, jaccard_f32x);
+                        nonzero_b32x, svsub_f32_x(predicate_all_b32x, one_f32x, ratio_f32x), one_f32x);
+                    svst1_f32(predicate_all_b32x, c_row + (row_tile_b + 0) * tile_dim, jaccard_f32x);
                 }
                 // ZA2
                 {
-                    svuint32_t za2_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_f32x, 2, row);
-                    svfloat32_t matching_f32x = svcvt_f32_u32_x(predicate_all_f32x, za2_u32x);
-                    svfloat32_t sum_norms_f32x = svadd_f32_x(predicate_all_f32x, norm_a_f32x, b_norms_1_f32x);
+                    svuint32_t za2_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_b32x, 2, row);
+                    svfloat32_t matching_f32x = svcvt_f32_u32_x(predicate_all_b32x, za2_u32x);
+                    svfloat32_t sum_norms_f32x = svadd_f32_x(predicate_all_b32x, norm_a_f32x, b_norms_1_f32x);
                     svfloat32_t intersection_f32x = svmul_f32_x(
-                        predicate_all_f32x,
-                        svadd_f32_x(predicate_all_f32x, svsub_f32_x(predicate_all_f32x, sum_norms_f32x, depth_f32x),
+                        predicate_all_b32x,
+                        svadd_f32_x(predicate_all_b32x, svsub_f32_x(predicate_all_b32x, sum_norms_f32x, depth_f32x),
                                     matching_f32x),
                         half_f32x);
-                    svfloat32_t union_val_f32x = svsub_f32_x(predicate_all_f32x, sum_norms_f32x, intersection_f32x);
-                    svbool_t nonzero_f32x = svcmpne_f32(predicate_all_f32x, union_val_f32x, zero_f32x);
-                    svfloat32_t ratio_f32x = svdiv_f32_x(predicate_all_f32x, intersection_f32x, union_val_f32x);
+                    svfloat32_t union_val_f32x = svsub_f32_x(predicate_all_b32x, sum_norms_f32x, intersection_f32x);
+                    svbool_t nonzero_b32x = svcmpne_f32(predicate_all_b32x, union_val_f32x, zero_f32x);
+                    svfloat32_t ratio_f32x = svdiv_f32_x(predicate_all_b32x, intersection_f32x, union_val_f32x);
                     svfloat32_t jaccard_f32x = svsel_f32(
-                        nonzero_f32x, svsub_f32_x(predicate_all_f32x, one_f32x, ratio_f32x), one_f32x);
-                    svst1_f32(predicate_all_f32x, c_row + (row_tile_b + 1) * tile_dim, jaccard_f32x);
+                        nonzero_b32x, svsub_f32_x(predicate_all_b32x, one_f32x, ratio_f32x), one_f32x);
+                    svst1_f32(predicate_all_b32x, c_row + (row_tile_b + 1) * tile_dim, jaccard_f32x);
                 }
                 // ZA3
                 {
-                    svuint32_t za3_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_f32x, 3, row);
-                    svfloat32_t matching_f32x = svcvt_f32_u32_x(predicate_all_f32x, za3_u32x);
-                    svfloat32_t sum_norms_f32x = svadd_f32_x(predicate_all_f32x, norm_a_f32x, b_norms_2_f32x);
+                    svuint32_t za3_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_b32x, 3, row);
+                    svfloat32_t matching_f32x = svcvt_f32_u32_x(predicate_all_b32x, za3_u32x);
+                    svfloat32_t sum_norms_f32x = svadd_f32_x(predicate_all_b32x, norm_a_f32x, b_norms_2_f32x);
                     svfloat32_t intersection_f32x = svmul_f32_x(
-                        predicate_all_f32x,
-                        svadd_f32_x(predicate_all_f32x, svsub_f32_x(predicate_all_f32x, sum_norms_f32x, depth_f32x),
+                        predicate_all_b32x,
+                        svadd_f32_x(predicate_all_b32x, svsub_f32_x(predicate_all_b32x, sum_norms_f32x, depth_f32x),
                                     matching_f32x),
                         half_f32x);
-                    svfloat32_t union_val_f32x = svsub_f32_x(predicate_all_f32x, sum_norms_f32x, intersection_f32x);
-                    svbool_t nonzero_f32x = svcmpne_f32(predicate_all_f32x, union_val_f32x, zero_f32x);
-                    svfloat32_t ratio_f32x = svdiv_f32_x(predicate_all_f32x, intersection_f32x, union_val_f32x);
+                    svfloat32_t union_val_f32x = svsub_f32_x(predicate_all_b32x, sum_norms_f32x, intersection_f32x);
+                    svbool_t nonzero_b32x = svcmpne_f32(predicate_all_b32x, union_val_f32x, zero_f32x);
+                    svfloat32_t ratio_f32x = svdiv_f32_x(predicate_all_b32x, intersection_f32x, union_val_f32x);
                     svfloat32_t jaccard_f32x = svsel_f32(
-                        nonzero_f32x, svsub_f32_x(predicate_all_f32x, one_f32x, ratio_f32x), one_f32x);
-                    svst1_f32(predicate_all_f32x, c_row + (row_tile_b + 2) * tile_dim, jaccard_f32x);
+                        nonzero_b32x, svsub_f32_x(predicate_all_b32x, one_f32x, ratio_f32x), one_f32x);
+                    svst1_f32(predicate_all_b32x, c_row + (row_tile_b + 2) * tile_dim, jaccard_f32x);
                 }
             }
         }
@@ -712,60 +737,60 @@ __arm_locally_streaming __arm_new("za") static void nk_jaccards_packed_u1_smebi3
             nk_size_t const row_start_b = row_tile_b * tile_dim;
             nk_size_t const rows_b_remaining = (row_start_b + tile_dim <= row_count_b) ? tile_dim
                                                                                        : (row_count_b - row_start_b);
-            svbool_t const column_predicate_f32x = svwhilelt_b32_u64(0u, rows_b_remaining);
+            svbool_t const column_predicate_b32x = svwhilelt_b32_u64(0u, rows_b_remaining);
 
             svzero_mask_za(nk_sme_zero_za32_tile_1_);
 
             for (nk_size_t d_tile = 0; d_tile < depth_tile_count; d_tile++) {
                 nk_size_t const d_start_u32 = d_tile * depth_tile_size;
-                nk_size_t const u32s_this_tile = (d_start_u32 + depth_tile_size <= depth_u32_total)
+                nk_size_t const u32s_this_tile = (d_start_u32 + depth_tile_size <= depth_words)
                                                      ? depth_tile_size
-                                                     : (depth_u32_total > d_start_u32 ? depth_u32_total - d_start_u32
-                                                                                      : 0);
+                                                     : (depth_words > d_start_u32 ? depth_words - d_start_u32 : 0);
                 if (u32s_this_tile == 0) break;
 
                 svzero_mask_za(nk_sme_zero_za32_tile_0_);
 
-                svbool_t const batch_predicate_f32x = svwhilelt_b32_u64(0u, u32s_this_tile);
+                svbool_t const batch_predicate_b32x = svwhilelt_b32_u64(0u, u32s_this_tile);
 
                 // Load A rows into ZA0.S horizontally
+                svbool_t const depth_predicate_b8x = svwhilelt_b8_u64(d_start_u32 * 4, depth_bytes);
                 for (nk_size_t row_in_tile = 0; row_in_tile < rows_a_remaining; row_in_tile++) {
-                    nk_u32_t const *a_row_u32 = (nk_u32_t const *)((char const *)a +
-                                                                   (row_start_a + row_in_tile) * a_stride_in_bytes) +
-                                                d_start_u32;
-                    svld1_hor_za32(0, row_in_tile, batch_predicate_f32x, a_row_u32);
+                    nk_u8_t const *a_row = (nk_u8_t const *)a + (row_start_a + row_in_tile) * a_stride_in_bytes +
+                                           d_start_u32 * 4;
+                    svuint8_t row_u8x = svld1_u8(depth_predicate_b8x, a_row);
+                    svwrite_hor_za32_u32_m(0, row_in_tile, batch_predicate_b32x, svreinterpret_u32_u8(row_u8x));
                 }
 
                 nk_u32_t const *b_tile = b_tiles + (row_tile_b * depth_tile_count + d_tile) * tile_elements;
 
                 // Vertical read + BMOPA
                 for (nk_size_t step = 0; step < u32s_this_tile; step++) {
-                    svuint32_t a_column_u32x = svread_ver_za32_u32_m(svdup_u32(0), row_predicate_f32x, 0, step);
-                    svuint32_t b_u32x = svld1_u32(predicate_all_f32x, b_tile + step * tile_dim);
-                    svbmopa_za32_u32_m(1, row_predicate_f32x, column_predicate_f32x, a_column_u32x, b_u32x);
+                    svuint32_t a_column_u32x = svread_ver_za32_u32_m(svdup_u32(0), row_predicate_b32x, 0, step);
+                    svuint32_t b_u32x = svld1_u32(predicate_all_b32x, b_tile + step * tile_dim);
+                    svbmopa_za32_u32_m(1, row_predicate_b32x, column_predicate_b32x, a_column_u32x, b_u32x);
                 }
             }
 
             // Extract from ZA1: Jaccard normalization
-            svfloat32_t b_norms_f32x = svcvt_f32_u32_x(predicate_all_f32x,
-                                                       svld1_u32(predicate_all_f32x, b_norms + row_start_b));
+            svfloat32_t b_norms_f32x = svcvt_f32_u32_x(predicate_all_b32x,
+                                                       svld1_u32(predicate_all_b32x, b_norms + row_start_b));
             for (nk_size_t row = 0; row < rows_a_remaining; row++) {
-                svuint32_t za1_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_f32x, 1, row);
-                svfloat32_t matching_f32x = svcvt_f32_u32_x(predicate_all_f32x, za1_u32x);
+                svuint32_t za1_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_b32x, 1, row);
+                svfloat32_t matching_f32x = svcvt_f32_u32_x(predicate_all_b32x, za1_u32x);
                 svfloat32_t norm_a_f32x = svdup_f32(a_tile_norms[row]);
-                svfloat32_t sum_norms_f32x = svadd_f32_x(predicate_all_f32x, norm_a_f32x, b_norms_f32x);
+                svfloat32_t sum_norms_f32x = svadd_f32_x(predicate_all_b32x, norm_a_f32x, b_norms_f32x);
                 svfloat32_t intersection_f32x = svmul_f32_x(
-                    predicate_all_f32x,
-                    svadd_f32_x(predicate_all_f32x, svsub_f32_x(predicate_all_f32x, sum_norms_f32x, depth_f32x),
+                    predicate_all_b32x,
+                    svadd_f32_x(predicate_all_b32x, svsub_f32_x(predicate_all_b32x, sum_norms_f32x, depth_f32x),
                                 matching_f32x),
                     half_f32x);
-                svfloat32_t union_val_f32x = svsub_f32_x(predicate_all_f32x, sum_norms_f32x, intersection_f32x);
-                svbool_t nonzero_f32x = svcmpne_f32(predicate_all_f32x, union_val_f32x, zero_f32x);
-                svfloat32_t ratio_f32x = svdiv_f32_x(predicate_all_f32x, intersection_f32x, union_val_f32x);
-                svfloat32_t jaccard_f32x = svsel_f32(nonzero_f32x,
-                                                     svsub_f32_x(predicate_all_f32x, one_f32x, ratio_f32x), one_f32x);
+                svfloat32_t union_val_f32x = svsub_f32_x(predicate_all_b32x, sum_norms_f32x, intersection_f32x);
+                svbool_t nonzero_b32x = svcmpne_f32(predicate_all_b32x, union_val_f32x, zero_f32x);
+                svfloat32_t ratio_f32x = svdiv_f32_x(predicate_all_b32x, intersection_f32x, union_val_f32x);
+                svfloat32_t jaccard_f32x = svsel_f32(nonzero_b32x,
+                                                     svsub_f32_x(predicate_all_b32x, one_f32x, ratio_f32x), one_f32x);
                 nk_f32_t *c_row = (nk_f32_t *)((char *)c + (row_start_a + row) * c_stride_in_bytes);
-                svst1_f32(column_predicate_f32x, c_row + row_start_b, jaccard_f32x);
+                svst1_f32(column_predicate_b32x, c_row + row_start_b, jaccard_f32x);
             }
         }
     }
@@ -784,17 +809,19 @@ NK_PUBLIC void nk_jaccards_packed_u1_smebi32(nk_u1x8_t const *a, void const *b_p
  *  Norms computed on-the-fly using streaming SVE popcount.
  */
 __arm_locally_streaming __arm_new("za") static void nk_jaccards_symmetric_u1_smebi32_streaming_(
-    nk_u1x8_t const *vectors, nk_size_t n_vectors, nk_size_t depth_bits, nk_size_t stride, nk_f32_t *result,
-    nk_size_t result_stride, nk_size_t row_start, nk_size_t row_count) {
+    nk_u1x8_t const *vectors, nk_size_t vectors_count, nk_size_t depth_bits, nk_size_t stride_in_bytes,
+    nk_f32_t *result, nk_size_t result_stride_in_bytes, nk_size_t row_start, nk_size_t row_count) {
 
     nk_size_t const tile_dim = svcntw();        // 16 for 512-bit SVL
     nk_size_t const depth_tile_size = svcntw(); // 16 u32 per depth tile
-    nk_size_t const depth_u32_total = nk_size_divide_round_up_(depth_bits, 32);
-    nk_size_t const depth_tile_count = nk_size_divide_round_up_(depth_u32_total, depth_tile_size);
-    nk_size_t const depth_in_bytes = nk_size_divide_round_up_(depth_bits, NK_BITS_PER_BYTE);
-
-    svbool_t const predicate_all_f32x = svptrue_b32();
-    svfloat32_t const depth_f32x = svdup_f32((nk_f32_t)depth_bits);
+    // BMOPA processes binary data in 32-bit words: each svbmopa_za32_u32_m step
+    // handles one u32 (32 bits) across all row×column pairs simultaneously.
+    nk_size_t const depth_words = nk_size_divide_round_up_(depth_bits, 32);
+    nk_size_t const depth_tile_count = nk_size_divide_round_up_(depth_words, depth_tile_size);
+    nk_size_t const depth_bytes = depth_bits / 8;
+
+    svbool_t const predicate_all_b32x = svptrue_b32();
+    svfloat32_t const depth_f32x = svdup_f32((nk_f32_t)(depth_words * 32));
     svfloat32_t const half_f32x = svdup_f32(0.5f);
     svfloat32_t const one_f32x = svdup_f32(1.0f);
     svfloat32_t const zero_f32x = svdup_f32(0.0f);
@@ -802,20 +829,22 @@ __arm_locally_streaming __arm_new("za") static void nk_jaccards_symmetric_u1_sme
     NK_ALIGN64 nk_u32_t a_buffer[16][16]; // Stack buffer for A column save
 
     nk_size_t const row_end = row_start + row_count;
-    nk_size_t const column_tile_count = nk_size_divide_round_up_(n_vectors, tile_dim);
+    nk_size_t const column_tile_count = nk_size_divide_round_up_(vectors_count, tile_dim);
 
-    for (nk_size_t row_tile_start = row_start; row_tile_start < row_end && row_tile_start < n_vectors;
+    for (nk_size_t row_tile_start = row_start; row_tile_start < row_end && row_tile_start < vectors_count;
          row_tile_start += tile_dim) {
         nk_size_t const rows_remaining = (row_tile_start + tile_dim <= row_end) ? tile_dim : (row_end - row_tile_start);
-        nk_size_t const rows_clamped = (row_tile_start + rows_remaining <= n_vectors) ? rows_remaining
-                                                                                      : (n_vectors - row_tile_start);
-        svbool_t const row_predicate_f32x = svwhilelt_b32_u64(0u, rows_clamped);
+        nk_size_t const rows_clamped = (row_tile_start + rows_remaining <= vectors_count)
+                                           ? rows_remaining
+                                           : (vectors_count - row_tile_start);
+        svbool_t const row_predicate_b32x = svwhilelt_b32_u64(0u, rows_clamped);
 
         // Compute A tile norms
         NK_ALIGN64 nk_f32_t a_tile_norms[16];
         for (nk_size_t r = 0; r < rows_clamped; r++) {
-            nk_u1x8_t const *a_row = (nk_u1x8_t const *)((char const *)vectors + (row_tile_start + r) * stride);
-            a_tile_norms[r] = (nk_f32_t)nk_sets_reduce_sumsq_u1_streaming_(a_row, depth_in_bytes);
+            nk_u1x8_t const *a_row = (nk_u1x8_t const *)((char const *)vectors +
+                                                         (row_tile_start + r) * stride_in_bytes);
+            a_tile_norms[r] = (nk_f32_t)nk_sets_reduce_sumsq_u1_streaming_(a_row, depth_bytes);
         }
         for (nk_size_t r = rows_clamped; r < tile_dim; r++) a_tile_norms[r] = 0.0f;
 
@@ -828,74 +857,74 @@ __arm_locally_streaming __arm_new("za") static void nk_jaccards_symmetric_u1_sme
 
             for (nk_size_t d_tile = 0; d_tile < depth_tile_count; d_tile++) {
                 nk_size_t const d_start_u32 = d_tile * depth_tile_size;
-                nk_size_t const u32s_this_tile = (d_start_u32 + depth_tile_size <= depth_u32_total)
+                nk_size_t const u32s_this_tile = (d_start_u32 + depth_tile_size <= depth_words)
                                                      ? depth_tile_size
-                                                     : (depth_u32_total > d_start_u32 ? depth_u32_total - d_start_u32
-                                                                                      : 0);
+                                                     : (depth_words > d_start_u32 ? depth_words - d_start_u32 : 0);
                 if (u32s_this_tile == 0) break;
 
                 // Load A rows into ZA0 horizontally
                 svzero_mask_za(nk_sme_zero_za32_tile_0_);
-                svbool_t const batch_predicate_f32x = svwhilelt_b32_u64(0u, u32s_this_tile);
+                svbool_t const batch_predicate_b32x = svwhilelt_b32_u64(0u, u32s_this_tile);
 
+                svbool_t const depth_predicate_b8x = svwhilelt_b8_u64(d_start_u32 * 4, depth_bytes);
                 for (nk_size_t row_in_tile = 0; row_in_tile < rows_clamped; row_in_tile++) {
-                    nk_u32_t const *a_row_u32 = (nk_u32_t const *)((char const *)vectors +
-                                                                   (row_tile_start + row_in_tile) * stride) +
-                                                d_start_u32;
-                    svld1_hor_za32(0, row_in_tile, batch_predicate_f32x, a_row_u32);
+                    nk_u8_t const *a_row = (nk_u8_t const *)vectors + (row_tile_start + row_in_tile) * stride_in_bytes +
+                                           d_start_u32 * 4;
+                    svuint8_t row_u8x = svld1_u8(depth_predicate_b8x, a_row);
+                    svwrite_hor_za32_u32_m(0, row_in_tile, batch_predicate_b32x, svreinterpret_u32_u8(row_u8x));
                 }
 
                 // Save A columns from ZA0 to stack buffer
                 for (nk_size_t s = 0; s < u32s_this_tile; s++)
-                    svst1_u32(predicate_all_f32x, a_buffer[s],
-                              svread_ver_za32_u32_m(svdup_u32(0), row_predicate_f32x, 0, s));
+                    svst1_u32(predicate_all_b32x, a_buffer[s],
+                              svread_ver_za32_u32_m(svdup_u32(0), row_predicate_b32x, 0, s));
 
                 // B column tile 0
                 svzero_mask_za(nk_sme_zero_za32_tile_0_);
                 for (nk_size_t col = 0; col < tile_dim; col++) {
                     nk_size_t const col_abs = (column_tile_index + 0) * tile_dim + col;
-                    if (col_abs < n_vectors) {
-                        nk_u32_t const *b_row = (nk_u32_t const *)((char const *)vectors + col_abs * stride) +
-                                                d_start_u32;
-                        svld1_hor_za32(0, col, batch_predicate_f32x, b_row);
+                    if (col_abs < vectors_count) {
+                        nk_u8_t const *b_row = (nk_u8_t const *)vectors + col_abs * stride_in_bytes + d_start_u32 * 4;
+                        svuint8_t col_u8x = svld1_u8(depth_predicate_b8x, b_row);
+                        svwrite_hor_za32_u32_m(0, col, batch_predicate_b32x, svreinterpret_u32_u8(col_u8x));
                     }
                 }
                 for (nk_size_t step = 0; step < u32s_this_tile; step++) {
-                    svuint32_t a_u32x = svld1_u32(predicate_all_f32x, a_buffer[step]);
-                    svuint32_t b_u32x = svread_ver_za32_u32_m(svdup_u32(0), predicate_all_f32x, 0, step);
-                    svbmopa_za32_u32_m(1, row_predicate_f32x, predicate_all_f32x, a_u32x, b_u32x);
+                    svuint32_t a_u32x = svld1_u32(predicate_all_b32x, a_buffer[step]);
+                    svuint32_t b_u32x = svread_ver_za32_u32_m(svdup_u32(0), predicate_all_b32x, 0, step);
+                    svbmopa_za32_u32_m(1, row_predicate_b32x, predicate_all_b32x, a_u32x, b_u32x);
                 }
 
                 // B column tile 1
                 svzero_mask_za(nk_sme_zero_za32_tile_0_);
                 for (nk_size_t col = 0; col < tile_dim; col++) {
                     nk_size_t const col_abs = (column_tile_index + 1) * tile_dim + col;
-                    if (col_abs < n_vectors) {
-                        nk_u32_t const *b_row = (nk_u32_t const *)((char const *)vectors + col_abs * stride) +
-                                                d_start_u32;
-                        svld1_hor_za32(0, col, batch_predicate_f32x, b_row);
+                    if (col_abs < vectors_count) {
+                        nk_u8_t const *b_row = (nk_u8_t const *)vectors + col_abs * stride_in_bytes + d_start_u32 * 4;
+                        svuint8_t col_u8x = svld1_u8(depth_predicate_b8x, b_row);
+                        svwrite_hor_za32_u32_m(0, col, batch_predicate_b32x, svreinterpret_u32_u8(col_u8x));
                     }
                 }
                 for (nk_size_t step = 0; step < u32s_this_tile; step++) {
-                    svuint32_t a_u32x = svld1_u32(predicate_all_f32x, a_buffer[step]);
-                    svuint32_t b_u32x = svread_ver_za32_u32_m(svdup_u32(0), predicate_all_f32x, 0, step);
-                    svbmopa_za32_u32_m(2, row_predicate_f32x, predicate_all_f32x, a_u32x, b_u32x);
+                    svuint32_t a_u32x = svld1_u32(predicate_all_b32x, a_buffer[step]);
+                    svuint32_t b_u32x = svread_ver_za32_u32_m(svdup_u32(0), predicate_all_b32x, 0, step);
+                    svbmopa_za32_u32_m(2, row_predicate_b32x, predicate_all_b32x, a_u32x, b_u32x);
                 }
 
                 // B column tile 2
                 svzero_mask_za(nk_sme_zero_za32_tile_0_);
                 for (nk_size_t col = 0; col < tile_dim; col++) {
                     nk_size_t const col_abs = (column_tile_index + 2) * tile_dim + col;
-                    if (col_abs < n_vectors) {
-                        nk_u32_t const *b_row = (nk_u32_t const *)((char const *)vectors + col_abs * stride) +
-                                                d_start_u32;
-                        svld1_hor_za32(0, col, batch_predicate_f32x, b_row);
+                    if (col_abs < vectors_count) {
+                        nk_u8_t const *b_row = (nk_u8_t const *)vectors + col_abs * stride_in_bytes + d_start_u32 * 4;
+                        svuint8_t col_u8x = svld1_u8(depth_predicate_b8x, b_row);
+                        svwrite_hor_za32_u32_m(0, col, batch_predicate_b32x, svreinterpret_u32_u8(col_u8x));
                     }
                 }
                 for (nk_size_t step = 0; step < u32s_this_tile; step++) {
-                    svuint32_t a_u32x = svld1_u32(predicate_all_f32x, a_buffer[step]);
-                    svuint32_t b_u32x = svread_ver_za32_u32_m(svdup_u32(0), predicate_all_f32x, 0, step);
-                    svbmopa_za32_u32_m(3, row_predicate_f32x, predicate_all_f32x, a_u32x, b_u32x);
+                    svuint32_t a_u32x = svld1_u32(predicate_all_b32x, a_buffer[step]);
+                    svuint32_t b_u32x = svread_ver_za32_u32_m(svdup_u32(0), predicate_all_b32x, 0, step);
+                    svbmopa_za32_u32_m(3, row_predicate_b32x, predicate_all_b32x, a_u32x, b_u32x);
                 }
             }
 
@@ -907,85 +936,85 @@ __arm_locally_streaming __arm_new("za") static void nk_jaccards_symmetric_u1_sme
                 nk_size_t const col_abs_0 = (column_tile_index + 0) * tile_dim + col;
                 nk_size_t const col_abs_1 = (column_tile_index + 1) * tile_dim + col;
                 nk_size_t const col_abs_2 = (column_tile_index + 2) * tile_dim + col;
-                b_tile_norms_0[col] = (col_abs_0 < n_vectors)
-                                          ? nk_sets_reduce_sumsq_u1_streaming_(
-                                                (nk_u1x8_t const *)((char const *)vectors + col_abs_0 * stride),
-                                                depth_in_bytes)
-                                          : 0;
-                b_tile_norms_1[col] = (col_abs_1 < n_vectors)
-                                          ? nk_sets_reduce_sumsq_u1_streaming_(
-                                                (nk_u1x8_t const *)((char const *)vectors + col_abs_1 * stride),
-                                                depth_in_bytes)
-                                          : 0;
-                b_tile_norms_2[col] = (col_abs_2 < n_vectors)
-                                          ? nk_sets_reduce_sumsq_u1_streaming_(
-                                                (nk_u1x8_t const *)((char const *)vectors + col_abs_2 * stride),
-                                                depth_in_bytes)
-                                          : 0;
+                b_tile_norms_0[col] =
+                    (col_abs_0 < vectors_count)
+                        ? nk_sets_reduce_sumsq_u1_streaming_(
+                              (nk_u1x8_t const *)((char const *)vectors + col_abs_0 * stride_in_bytes), depth_bytes)
+                        : 0;
+                b_tile_norms_1[col] =
+                    (col_abs_1 < vectors_count)
+                        ? nk_sets_reduce_sumsq_u1_streaming_(
+                              (nk_u1x8_t const *)((char const *)vectors + col_abs_1 * stride_in_bytes), depth_bytes)
+                        : 0;
+                b_tile_norms_2[col] =
+                    (col_abs_2 < vectors_count)
+                        ? nk_sets_reduce_sumsq_u1_streaming_(
+                              (nk_u1x8_t const *)((char const *)vectors + col_abs_2 * stride_in_bytes), depth_bytes)
+                        : 0;
             }
 
             // Extract ZA1-3: Jaccard normalization
-            svfloat32_t b_norms_0_f32x = svcvt_f32_u32_x(predicate_all_f32x,
-                                                         svld1_u32(predicate_all_f32x, b_tile_norms_0));
-            svfloat32_t b_norms_1_f32x = svcvt_f32_u32_x(predicate_all_f32x,
-                                                         svld1_u32(predicate_all_f32x, b_tile_norms_1));
-            svfloat32_t b_norms_2_f32x = svcvt_f32_u32_x(predicate_all_f32x,
-                                                         svld1_u32(predicate_all_f32x, b_tile_norms_2));
+            svfloat32_t b_norms_0_f32x = svcvt_f32_u32_x(predicate_all_b32x,
+                                                         svld1_u32(predicate_all_b32x, b_tile_norms_0));
+            svfloat32_t b_norms_1_f32x = svcvt_f32_u32_x(predicate_all_b32x,
+                                                         svld1_u32(predicate_all_b32x, b_tile_norms_1));
+            svfloat32_t b_norms_2_f32x = svcvt_f32_u32_x(predicate_all_b32x,
+                                                         svld1_u32(predicate_all_b32x, b_tile_norms_2));
 
             for (nk_size_t row = 0; row < rows_clamped; row++) {
-                nk_f32_t *c_row = (nk_f32_t *)((char *)result + (row_tile_start + row) * result_stride);
+                nk_f32_t *c_row = (nk_f32_t *)((char *)result + (row_tile_start + row) * result_stride_in_bytes);
                 svfloat32_t norm_a_f32x = svdup_f32(a_tile_norms[row]);
 
                 // ZA1
                 {
-                    svuint32_t za1_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_f32x, 1, row);
-                    svfloat32_t matching_f32x = svcvt_f32_u32_x(predicate_all_f32x, za1_u32x);
-                    svfloat32_t sum_norms_f32x = svadd_f32_x(predicate_all_f32x, norm_a_f32x, b_norms_0_f32x);
+                    svuint32_t za1_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_b32x, 1, row);
+                    svfloat32_t matching_f32x = svcvt_f32_u32_x(predicate_all_b32x, za1_u32x);
+                    svfloat32_t sum_norms_f32x = svadd_f32_x(predicate_all_b32x, norm_a_f32x, b_norms_0_f32x);
                     svfloat32_t intersection_f32x = svmul_f32_x(
-                        predicate_all_f32x,
-                        svadd_f32_x(predicate_all_f32x, svsub_f32_x(predicate_all_f32x, sum_norms_f32x, depth_f32x),
+                        predicate_all_b32x,
+                        svadd_f32_x(predicate_all_b32x, svsub_f32_x(predicate_all_b32x, sum_norms_f32x, depth_f32x),
                                     matching_f32x),
                         half_f32x);
-                    svfloat32_t union_val_f32x = svsub_f32_x(predicate_all_f32x, sum_norms_f32x, intersection_f32x);
-                    svbool_t nonzero_f32x = svcmpne_f32(predicate_all_f32x, union_val_f32x, zero_f32x);
-                    svfloat32_t ratio_f32x = svdiv_f32_x(predicate_all_f32x, intersection_f32x, union_val_f32x);
+                    svfloat32_t union_val_f32x = svsub_f32_x(predicate_all_b32x, sum_norms_f32x, intersection_f32x);
+                    svbool_t nonzero_b32x = svcmpne_f32(predicate_all_b32x, union_val_f32x, zero_f32x);
+                    svfloat32_t ratio_f32x = svdiv_f32_x(predicate_all_b32x, intersection_f32x, union_val_f32x);
                     svfloat32_t jaccard_f32x = svsel_f32(
-                        nonzero_f32x, svsub_f32_x(predicate_all_f32x, one_f32x, ratio_f32x), one_f32x);
-                    svst1_f32(predicate_all_f32x, c_row + (column_tile_index + 0) * tile_dim, jaccard_f32x);
+                        nonzero_b32x, svsub_f32_x(predicate_all_b32x, one_f32x, ratio_f32x), one_f32x);
+                    svst1_f32(predicate_all_b32x, c_row + (column_tile_index + 0) * tile_dim, jaccard_f32x);
                 }
                 // ZA2
                 {
-                    svuint32_t za2_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_f32x, 2, row);
-                    svfloat32_t matching_f32x = svcvt_f32_u32_x(predicate_all_f32x, za2_u32x);
-                    svfloat32_t sum_norms_f32x = svadd_f32_x(predicate_all_f32x, norm_a_f32x, b_norms_1_f32x);
+                    svuint32_t za2_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_b32x, 2, row);
+                    svfloat32_t matching_f32x = svcvt_f32_u32_x(predicate_all_b32x, za2_u32x);
+                    svfloat32_t sum_norms_f32x = svadd_f32_x(predicate_all_b32x, norm_a_f32x, b_norms_1_f32x);
                     svfloat32_t intersection_f32x = svmul_f32_x(
-                        predicate_all_f32x,
-                        svadd_f32_x(predicate_all_f32x, svsub_f32_x(predicate_all_f32x, sum_norms_f32x, depth_f32x),
+                        predicate_all_b32x,
+                        svadd_f32_x(predicate_all_b32x, svsub_f32_x(predicate_all_b32x, sum_norms_f32x, depth_f32x),
                                     matching_f32x),
                         half_f32x);
-                    svfloat32_t union_val_f32x = svsub_f32_x(predicate_all_f32x, sum_norms_f32x, intersection_f32x);
-                    svbool_t nonzero_f32x = svcmpne_f32(predicate_all_f32x, union_val_f32x, zero_f32x);
-                    svfloat32_t ratio_f32x = svdiv_f32_x(predicate_all_f32x, intersection_f32x, union_val_f32x);
+                    svfloat32_t union_val_f32x = svsub_f32_x(predicate_all_b32x, sum_norms_f32x, intersection_f32x);
+                    svbool_t nonzero_b32x = svcmpne_f32(predicate_all_b32x, union_val_f32x, zero_f32x);
+                    svfloat32_t ratio_f32x = svdiv_f32_x(predicate_all_b32x, intersection_f32x, union_val_f32x);
                     svfloat32_t jaccard_f32x = svsel_f32(
-                        nonzero_f32x, svsub_f32_x(predicate_all_f32x, one_f32x, ratio_f32x), one_f32x);
-                    svst1_f32(predicate_all_f32x, c_row + (column_tile_index + 1) * tile_dim, jaccard_f32x);
+                        nonzero_b32x, svsub_f32_x(predicate_all_b32x, one_f32x, ratio_f32x), one_f32x);
+                    svst1_f32(predicate_all_b32x, c_row + (column_tile_index + 1) * tile_dim, jaccard_f32x);
                 }
                 // ZA3
                 {
-                    svuint32_t za3_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_f32x, 3, row);
-                    svfloat32_t matching_f32x = svcvt_f32_u32_x(predicate_all_f32x, za3_u32x);
-                    svfloat32_t sum_norms_f32x = svadd_f32_x(predicate_all_f32x, norm_a_f32x, b_norms_2_f32x);
+                    svuint32_t za3_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_b32x, 3, row);
+                    svfloat32_t matching_f32x = svcvt_f32_u32_x(predicate_all_b32x, za3_u32x);
+                    svfloat32_t sum_norms_f32x = svadd_f32_x(predicate_all_b32x, norm_a_f32x, b_norms_2_f32x);
                     svfloat32_t intersection_f32x = svmul_f32_x(
-                        predicate_all_f32x,
-                        svadd_f32_x(predicate_all_f32x, svsub_f32_x(predicate_all_f32x, sum_norms_f32x, depth_f32x),
+                        predicate_all_b32x,
+                        svadd_f32_x(predicate_all_b32x, svsub_f32_x(predicate_all_b32x, sum_norms_f32x, depth_f32x),
                                     matching_f32x),
                         half_f32x);
-                    svfloat32_t union_val_f32x = svsub_f32_x(predicate_all_f32x, sum_norms_f32x, intersection_f32x);
-                    svbool_t nonzero_f32x = svcmpne_f32(predicate_all_f32x, union_val_f32x, zero_f32x);
-                    svfloat32_t ratio_f32x = svdiv_f32_x(predicate_all_f32x, intersection_f32x, union_val_f32x);
+                    svfloat32_t union_val_f32x = svsub_f32_x(predicate_all_b32x, sum_norms_f32x, intersection_f32x);
+                    svbool_t nonzero_b32x = svcmpne_f32(predicate_all_b32x, union_val_f32x, zero_f32x);
+                    svfloat32_t ratio_f32x = svdiv_f32_x(predicate_all_b32x, intersection_f32x, union_val_f32x);
                     svfloat32_t jaccard_f32x = svsel_f32(
-                        nonzero_f32x, svsub_f32_x(predicate_all_f32x, one_f32x, ratio_f32x), one_f32x);
-                    svst1_f32(predicate_all_f32x, c_row + (column_tile_index + 2) * tile_dim, jaccard_f32x);
+                        nonzero_b32x, svsub_f32_x(predicate_all_b32x, one_f32x, ratio_f32x), one_f32x);
+                    svst1_f32(predicate_all_b32x, c_row + (column_tile_index + 2) * tile_dim, jaccard_f32x);
                 }
             }
         }
@@ -993,50 +1022,51 @@ __arm_locally_streaming __arm_new("za") static void nk_jaccards_symmetric_u1_sme
         // Remainder: 1 column tile at a time using ZA1
         for (; column_tile_index < column_tile_count; column_tile_index++) {
             nk_size_t const col_tile_start = column_tile_index * tile_dim;
-            nk_size_t const cols_remaining = (col_tile_start + tile_dim <= n_vectors) ? tile_dim
-                                                                                      : (n_vectors - col_tile_start);
-            svbool_t const column_predicate_f32x = svwhilelt_b32_u64(0u, cols_remaining);
+            nk_size_t const cols_remaining = (col_tile_start + tile_dim <= vectors_count)
+                                                 ? tile_dim
+                                                 : (vectors_count - col_tile_start);
+            svbool_t const column_predicate_b32x = svwhilelt_b32_u64(0u, cols_remaining);
 
             svzero_mask_za(nk_sme_zero_za32_tile_1_);
 
             for (nk_size_t d_tile = 0; d_tile < depth_tile_count; d_tile++) {
                 nk_size_t const d_start_u32 = d_tile * depth_tile_size;
-                nk_size_t const u32s_this_tile = (d_start_u32 + depth_tile_size <= depth_u32_total)
+                nk_size_t const u32s_this_tile = (d_start_u32 + depth_tile_size <= depth_words)
                                                      ? depth_tile_size
-                                                     : (depth_u32_total > d_start_u32 ? depth_u32_total - d_start_u32
-                                                                                      : 0);
+                                                     : (depth_words > d_start_u32 ? depth_words - d_start_u32 : 0);
                 if (u32s_this_tile == 0) break;
 
                 svzero_mask_za(nk_sme_zero_za32_tile_0_);
-                svbool_t const batch_predicate_f32x = svwhilelt_b32_u64(0u, u32s_this_tile);
+                svbool_t const batch_predicate_b32x = svwhilelt_b32_u64(0u, u32s_this_tile);
 
                 // Load A rows into ZA0 horizontally
+                svbool_t const depth_predicate_b8x = svwhilelt_b8_u64(d_start_u32 * 4, depth_bytes);
                 for (nk_size_t row_in_tile = 0; row_in_tile < rows_clamped; row_in_tile++) {
-                    nk_u32_t const *a_row_u32 = (nk_u32_t const *)((char const *)vectors +
-                                                                   (row_tile_start + row_in_tile) * stride) +
-                                                d_start_u32;
-                    svld1_hor_za32(0, row_in_tile, batch_predicate_f32x, a_row_u32);
+                    nk_u8_t const *a_row = (nk_u8_t const *)vectors + (row_tile_start + row_in_tile) * stride_in_bytes +
+                                           d_start_u32 * 4;
+                    svuint8_t row_u8x = svld1_u8(depth_predicate_b8x, a_row);
+                    svwrite_hor_za32_u32_m(0, row_in_tile, batch_predicate_b32x, svreinterpret_u32_u8(row_u8x));
                 }
 
                 // Save A columns from ZA0 to stack buffer
                 for (nk_size_t s = 0; s < u32s_this_tile; s++)
-                    svst1_u32(predicate_all_f32x, a_buffer[s],
-                              svread_ver_za32_u32_m(svdup_u32(0), row_predicate_f32x, 0, s));
+                    svst1_u32(predicate_all_b32x, a_buffer[s],
+                              svread_ver_za32_u32_m(svdup_u32(0), row_predicate_b32x, 0, s));
 
                 // Load B column tile into ZA0
                 svzero_mask_za(nk_sme_zero_za32_tile_0_);
                 for (nk_size_t col = 0; col < tile_dim; col++) {
                     nk_size_t const col_abs = col_tile_start + col;
-                    if (col_abs < n_vectors) {
-                        nk_u32_t const *b_row = (nk_u32_t const *)((char const *)vectors + col_abs * stride) +
-                                                d_start_u32;
-                        svld1_hor_za32(0, col, batch_predicate_f32x, b_row);
+                    if (col_abs < vectors_count) {
+                        nk_u8_t const *b_row = (nk_u8_t const *)vectors + col_abs * stride_in_bytes + d_start_u32 * 4;
+                        svuint8_t col_u8x = svld1_u8(depth_predicate_b8x, b_row);
+                        svwrite_hor_za32_u32_m(0, col, batch_predicate_b32x, svreinterpret_u32_u8(col_u8x));
                     }
                 }
                 for (nk_size_t step = 0; step < u32s_this_tile; step++) {
-                    svuint32_t a_u32x = svld1_u32(predicate_all_f32x, a_buffer[step]);
-                    svuint32_t b_u32x = svread_ver_za32_u32_m(svdup_u32(0), column_predicate_f32x, 0, step);
-                    svbmopa_za32_u32_m(1, row_predicate_f32x, column_predicate_f32x, a_u32x, b_u32x);
+                    svuint32_t a_u32x = svld1_u32(predicate_all_b32x, a_buffer[step]);
+                    svuint32_t b_u32x = svread_ver_za32_u32_m(svdup_u32(0), column_predicate_b32x, 0, step);
+                    svbmopa_za32_u32_m(1, row_predicate_b32x, column_predicate_b32x, a_u32x, b_u32x);
                 }
             }
 
@@ -1044,44 +1074,45 @@ __arm_locally_streaming __arm_new("za") static void nk_jaccards_symmetric_u1_sme
             NK_ALIGN64 nk_u32_t b_tile_norms[16];
             for (nk_size_t col = 0; col < tile_dim; col++) {
                 nk_size_t const col_abs = col_tile_start + col;
-                b_tile_norms[col] = (col_abs < n_vectors)
+                b_tile_norms[col] = (col_abs < vectors_count)
                                         ? nk_sets_reduce_sumsq_u1_streaming_(
-                                              (nk_u1x8_t const *)((char const *)vectors + col_abs * stride),
-                                              depth_in_bytes)
+                                              (nk_u1x8_t const *)((char const *)vectors + col_abs * stride_in_bytes),
+                                              depth_bytes)
                                         : 0;
             }
 
-            svfloat32_t b_norms_f32x = svcvt_f32_u32_x(predicate_all_f32x, svld1_u32(predicate_all_f32x, b_tile_norms));
+            svfloat32_t b_norms_f32x = svcvt_f32_u32_x(predicate_all_b32x, svld1_u32(predicate_all_b32x, b_tile_norms));
             for (nk_size_t row = 0; row < rows_clamped; row++) {
-                svuint32_t za1_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_f32x, 1, row);
-                svfloat32_t matching_f32x = svcvt_f32_u32_x(predicate_all_f32x, za1_u32x);
+                svuint32_t za1_u32x = svread_hor_za32_u32_m(svdup_u32(0), predicate_all_b32x, 1, row);
+                svfloat32_t matching_f32x = svcvt_f32_u32_x(predicate_all_b32x, za1_u32x);
                 svfloat32_t norm_a_f32x = svdup_f32(a_tile_norms[row]);
-                svfloat32_t sum_norms_f32x = svadd_f32_x(predicate_all_f32x, norm_a_f32x, b_norms_f32x);
+                svfloat32_t sum_norms_f32x = svadd_f32_x(predicate_all_b32x, norm_a_f32x, b_norms_f32x);
                 svfloat32_t intersection_f32x = svmul_f32_x(
-                    predicate_all_f32x,
-                    svadd_f32_x(predicate_all_f32x, svsub_f32_x(predicate_all_f32x, sum_norms_f32x, depth_f32x),
+                    predicate_all_b32x,
+                    svadd_f32_x(predicate_all_b32x, svsub_f32_x(predicate_all_b32x, sum_norms_f32x, depth_f32x),
                                 matching_f32x),
                     half_f32x);
-                svfloat32_t union_val_f32x = svsub_f32_x(predicate_all_f32x, sum_norms_f32x, intersection_f32x);
-                svbool_t nonzero_f32x = svcmpne_f32(predicate_all_f32x, union_val_f32x, zero_f32x);
-                svfloat32_t ratio_f32x = svdiv_f32_x(predicate_all_f32x, intersection_f32x, union_val_f32x);
-                svfloat32_t jaccard_f32x = svsel_f32(nonzero_f32x,
-                                                     svsub_f32_x(predicate_all_f32x, one_f32x, ratio_f32x), one_f32x);
-                nk_f32_t *c_row = (nk_f32_t *)((char *)result + (row_tile_start + row) * result_stride);
-                svst1_f32(column_predicate_f32x, c_row + col_tile_start, jaccard_f32x);
+                svfloat32_t union_val_f32x = svsub_f32_x(predicate_all_b32x, sum_norms_f32x, intersection_f32x);
+                svbool_t nonzero_b32x = svcmpne_f32(predicate_all_b32x, union_val_f32x, zero_f32x);
+                svfloat32_t ratio_f32x = svdiv_f32_x(predicate_all_b32x, intersection_f32x, union_val_f32x);
+                svfloat32_t jaccard_f32x = svsel_f32(nonzero_b32x,
+                                                     svsub_f32_x(predicate_all_b32x, one_f32x, ratio_f32x), one_f32x);
+                nk_f32_t *c_row = (nk_f32_t *)((char *)result + (row_tile_start + row) * result_stride_in_bytes);
+                svst1_f32(column_predicate_b32x, c_row + col_tile_start, jaccard_f32x);
             }
         }
     }
 }
 
-NK_PUBLIC void nk_jaccards_symmetric_u1_smebi32(nk_u1x8_t const *vectors, nk_size_t n_vectors, nk_size_t depth_bits,
-                                                nk_size_t stride, nk_f32_t *result, nk_size_t result_stride,
-                                                nk_size_t row_start, nk_size_t row_count) {
-    nk_jaccards_symmetric_u1_smebi32_streaming_(vectors, n_vectors, depth_bits, stride, result, result_stride,
-                                                row_start, row_count);
+NK_PUBLIC void nk_jaccards_symmetric_u1_smebi32(nk_u1x8_t const *vectors, nk_size_t vectors_count, nk_size_t depth_bits,
+                                                nk_size_t stride_in_bytes, nk_f32_t *result,
+                                                nk_size_t result_stride_in_bytes, nk_size_t row_start,
+                                                nk_size_t row_count) {
+    nk_jaccards_symmetric_u1_smebi32_streaming_(vectors, vectors_count, depth_bits, stride_in_bytes, result,
+                                                result_stride_in_bytes, row_start, row_count);
 }
 
-#pragma endregion // Jaccard Distance
+#pragma endregion Jaccard Distance
 
 #if defined(__clang__)
 #pragma clang attribute pop