usearch 2.15.2 → 2.16.0

package/simsimd/include/simsimd/simsimd.h

@@ -23,6 +23,7 @@
  *         F, CD, VL, DQ, BW, VNNI, VPOPCNTDQ, IFMA, VBMI, VAES, GFNI, VBMI2, BITALG, VPCLMULQDQ, BF16
  *       > In other words, it extends Sunny Cove with BF16 support
  *  - Intel Golden Cove (Sapphire Rapids): extends Zen4 and Sunny Cove with FP16 support
+ *  - AMD Zen5 (Turin): makes VP2INTERSECT cool again
  *
  *  Intel Palm Cove was an irrelevant intermediate release extending Skylake with IFMA and VBMI.
  *  Intel Willow Cove was an irrelevant intermediate release extending Sunny Cove with VP2INTERSECT,
@@ -35,6 +36,7 @@
  *  2. Intel Ice Lake (2019-2021): advanced integer algorithms.
  *  3. AMD Genoa (2023+): brain-floating point support.
  *  4. Intel Sapphire Rapids (2023+): advanced mixed-precision float processing.
+ *  5. AMD Turin (2024+): advanced sparse algorithms.
  *
  *  To list all available macros for x86, take a recent compiler, like GCC 12 and run:
  *       gcc-12 -march=sapphirerapids -dM -E - < /dev/null | egrep "SSE|AVX" | sort
@@ -44,7 +46,7 @@
  *  @section    Choosing Arm Target Generations
  *
  *  Arm CPUs share design IP, but are produced by different vendors, potentially making the platform
- *  even more fragmented than x86. There are 2 imporatant families of SIMD extensions - NEON and SVE.
+ *  even more fragmented than x86. There are 2 important families of SIMD extensions - NEON and SVE.
  *
  *  - Armv8-A: +fp, +simd
  *  - Armv8.1-A: armv8-a, +crc, +lse, +rdma
@@ -68,7 +70,7 @@
  *  Here are the most important recent families of CPU cores designed by Arm:
  *
  *  - Neoverse N1: armv8.2-a, extended with Armv8.4 "dotprod" instructions.
- *    Used in AWS @b Graviton2 and Amere @b Altra.
+ *    Used in AWS @b Graviton2 and Ampere @b Altra.
  *    https://developer.arm.com/Processors/Neoverse%20N1
  *  - Neoverse V1: armv8.4-a, extended with Armv8.6 bfloat/int8 "matmul" instructions.
  *    Used in AWS @b Graviton3, which also enables `sve`, `svebf16`, and `svei8mm`.
@@ -87,8 +89,8 @@
 #define SIMSIMD_H
 
 #define SIMSIMD_VERSION_MAJOR 5
-#define SIMSIMD_VERSION_MINOR 0
-#define SIMSIMD_VERSION_PATCH 0
+#define SIMSIMD_VERSION_MINOR 9
+#define SIMSIMD_VERSION_PATCH 6
 
 /**
  *  @brief  Removes compile-time dispatching, and replaces it with runtime dispatching.
@@ -101,13 +103,16 @@
 #endif
 
 #include "binary.h"      // Hamming, Jaccard
+#include "curved.h"      // Mahalanobis, Bilinear Forms
 #include "dot.h"         // Inner (dot) product, and its conjugate
+#include "elementwise.h" // Weighted Sum, Fused-Multiply-Add
 #include "geospatial.h"  // Haversine and Vincenty
 #include "probability.h" // Kullback-Leibler, Jensen–Shannon
+#include "sparse.h"      // Intersect
 #include "spatial.h"     // L2, Cosine
 
 // On Apple Silicon, `mrs` is not allowed in user-space, so we need to use the `sysctl` API.
-#if defined(SIMSIMD_DEFINED_APPLE)
+#if defined(_SIMSIMD_DEFINED_APPLE)
 #include <sys/sysctl.h>
 #endif
 
@@ -132,6 +137,8 @@ typedef enum {
     simsimd_metric_cosine_k = 'c',  ///< Cosine similarity alias
     simsimd_metric_angular_k = 'c', ///< Cosine similarity alias
 
+    simsimd_metric_l2_k = '2',          ///< Euclidean distance alias
+    simsimd_metric_euclidean_k = '2',   ///< Euclidean distance alias
     simsimd_metric_l2sq_k = 'e',        ///< Squared Euclidean distance
     simsimd_metric_sqeuclidean_k = 'e', ///< Squared Euclidean distance alias
 
@@ -142,6 +149,15 @@ typedef enum {
     simsimd_metric_jaccard_k = 'j',  ///< Jaccard coefficient
     simsimd_metric_tanimoto_k = 'j', ///< Tanimoto coefficient is same as Jaccard
 
+    // Sets:
+    simsimd_metric_intersect_k = 'x',     ///< Equivalent to unnormalized Jaccard
+    simsimd_metric_spdot_counts_k = 'y',  ///< Sparse sets with integer weights
+    simsimd_metric_spdot_weights_k = 'z', ///< Sparse sets with brain floating-point weights
+
+    // Curved Spaces:
+    simsimd_metric_bilinear_k = 'b',    ///< Bilinear form
+    simsimd_metric_mahalanobis_k = 'm', ///< Mahalanobis distance
+
     // Probability:
     simsimd_metric_kl_k = 'k',               ///< Kullback-Leibler divergence
     simsimd_metric_kullback_leibler_k = 'k', ///< Kullback-Leibler divergence alias
@@ -149,6 +165,10 @@ typedef enum {
     simsimd_metric_js_k = 's',             ///< Jensen-Shannon divergence
     simsimd_metric_jensen_shannon_k = 's', ///< Jensen-Shannon divergence alias
 
+    // BLAS-like operations:
+    simsimd_metric_fma_k = 'f',  ///< Fused Multiply-Add
+    simsimd_metric_wsum_k = 'w', ///< Weighted Sum
+
 } simsimd_metric_kind_t;
 
 /**
@@ -163,15 +183,19 @@ typedef enum {
     simsimd_cap_ice_k = 1 << 12,      ///< x86 AVX512 capability with advanced integer algos
     simsimd_cap_genoa_k = 1 << 13,    ///< x86 AVX512 capability with `bf16` support
     simsimd_cap_sapphire_k = 1 << 14, ///< x86 AVX512 capability with `f16` support
-
-    simsimd_cap_neon_k = 1 << 20,      ///< ARM NEON capability
-    simsimd_cap_neon_f16_k = 1 << 21,  ///< ARM NEON FP16 capability
-    simsimd_cap_neon_bf16_k = 1 << 22, ///< ARM NEON BF16 capability
-    simsimd_cap_neon_i8_k = 1 << 23,   ///< ARM NEON Int8 capability
-    simsimd_cap_sve_k = 1 << 24,       ///< ARM SVE capability
-    simsimd_cap_sve_f16_k = 1 << 25,   ///< ARM SVE FP16 capability
-    simsimd_cap_sve_bf16_k = 1 << 26,  ///< ARM SVE BF16 capability
-    simsimd_cap_sve_i8_k = 1 << 27,    ///< ARM SVE Int8 capability
+    simsimd_cap_turin_k = 1 << 15,    ///< x86 AVX512 capability with conflict detection
+    simsimd_cap_sierra_k = 1 << 16,   ///< x86 AVX2+VNNI capability with `i8` dot-products
+
+    simsimd_cap_neon_k = 1 << 20,      ///< ARM NEON baseline capability
+    simsimd_cap_neon_f16_k = 1 << 21,  ///< ARM NEON `f16` capability
+    simsimd_cap_neon_bf16_k = 1 << 22, ///< ARM NEON `bf16` capability
+    simsimd_cap_neon_i8_k = 1 << 23,   ///< ARM NEON `i8` capability
+    simsimd_cap_sve_k = 1 << 24,       ///< ARM SVE baseline capability
+    simsimd_cap_sve_f16_k = 1 << 25,   ///< ARM SVE `f16` capability
+    simsimd_cap_sve_bf16_k = 1 << 26,  ///< ARM SVE `bf16` capability
+    simsimd_cap_sve_i8_k = 1 << 27,    ///< ARM SVE `i8` capability
+    simsimd_cap_sve2_k = 1 << 28,      ///< ARM SVE2 capability
+    simsimd_cap_sve2p1_k = 1 << 29,    ///< ARM SVE2p1 capability
 
 } simsimd_capability_t;
 
@@ -183,10 +207,20 @@ typedef enum {
  *  interfaces.
  */
 typedef enum {
-    simsimd_datatype_unknown_k = 0, ///< Unknown data type
+    simsimd_datatype_unknown_k = 0,                  ///< Unknown data type
+    simsimd_datatype_b8_k = 1 << 1,                  ///< Single-bit values packed into 8-bit words
+    simsimd_datatype_b1x8_k = simsimd_datatype_b8_k, ///< Single-bit values packed into 8-bit words
+    simsimd_datatype_i4x2_k = 1 << 19,               ///< 4-bit signed integers packed into 8-bit words
 
-    simsimd_datatype_b8_k = 1 << 1, ///< Single-bit values packed into 8-bit words
-    simsimd_datatype_i8_k = 1 << 2, ///< 8-bit integer
+    simsimd_datatype_i8_k = 1 << 2,  ///< 8-bit signed integer
+    simsimd_datatype_i16_k = 1 << 3, ///< 16-bit signed integer
+    simsimd_datatype_i32_k = 1 << 4, ///< 32-bit signed integer
+    simsimd_datatype_i64_k = 1 << 5, ///< 64-bit signed integer
+
+    simsimd_datatype_u8_k = 1 << 6,  ///< 8-bit unsigned integer
+    simsimd_datatype_u16_k = 1 << 7, ///< 16-bit unsigned integer
+    simsimd_datatype_u32_k = 1 << 8, ///< 32-bit unsigned integer
+    simsimd_datatype_u64_k = 1 << 9, ///< 64-bit unsigned integer
 
     simsimd_datatype_f64_k = 1 << 10,  ///< Double precision floating point
     simsimd_datatype_f32_k = 1 << 11,  ///< Single precision floating point
@@ -200,30 +234,108 @@ typedef enum {
 } simsimd_datatype_t;
 
 /**
- *  @brief  Type-punned function pointer accepting two vectors and outputting their similarity/distance.
+ *  @brief  Type-punned function pointer for dense vector representations and simplest similarity measures.
  *
  *  @param[in] a    Pointer to the first data array.
  *  @param[in] b    Pointer to the second data array.
  *  @param[in] n    Number of scalar words in the input arrays.
+ *                  When dealing with sub-byte types, the number of scalar words is the number of bytes.
+ *                  When dealing with complex types, the number of scalar words is the sum of real and imaginary parts.
  *  @param[out] d   Output value as a double-precision float.
- *                  In complex dot-products @b two double-precision scalars are exported
- *                  for the real and imaginary parts.
+ *                  In complex dot-products @b two scalars are exported for the real and imaginary parts.
+ */
+typedef void (*simsimd_metric_dense_punned_t)(void const *a, void const *b, simsimd_size_t n, simsimd_distance_t *d);
+
+/**
+ *  @brief  Type-punned function pointer for sparse vector representations and similarity measures.
+ *
+ *  @param[in] a          Pointer to the first data array, generally a sorted array of integers.
+ *  @param[in] b          Pointer to the second data array, generally a sorted array of integers.
+ *  @param[in] a_length   Number of scalar words in the first input array.
+ *  @param[in] b_length   Number of scalar words in the second input array.
+ *  @param[out] d         Output value as a double-precision float, generally without decimals.
+ */
+typedef void (*simsimd_metric_sparse_punned_t)(void const *a, void const *b,                     //
+                                               simsimd_size_t a_length, simsimd_size_t b_length, //
+                                               simsimd_distance_t *d);
+
+/**
+ *  @brief  Type-punned function pointer for curved vector spaces and similarity measures.
+ *
+ *  @param[in] a    Pointer to the first data array.
+ *  @param[in] b    Pointer to the second data array.
+ *  @param[in] c    Pointer to the metric tensor array or some covariance matrix.
+ *  @param[in] n    Number of scalar words in the input arrays.
+ *  @param[out] d   Output value as a double-precision float.
+ */
+typedef void (*simsimd_metric_curved_punned_t)(void const *a, void const *b, void const *c, //
+                                               simsimd_size_t n, simsimd_distance_t *d);
+
+/**
+ *  @brief  Type-punned function pointer for FMA operations on dense vector representations.
+ *          Implements the `y = alpha * a * b + beta * c` operation.
+ *
+ *  @param[in] a        Pointer to the first data array.
+ *  @param[in] b        Pointer to the second data array.
+ *  @param[in] c        Pointer to the third data array.
+ *  @param[in] n        Number of scalar words in the input arrays.
+ *  @param[in] alpha    Scaling factor for the first two arrays.
+ *  @param[in] beta     Scaling factor for the third array.
+ *  @param[out] y       Output value in the same precision as the input arrays.
+ */
+typedef void (*simsimd_kernel_fma_punned_t)(void const *a, void const *b, void const *c, //
+                                            simsimd_size_t n, simsimd_distance_t alpha, simsimd_distance_t beta,
+                                            void *y);
+
+/**
+ *  @brief  Type-punned function pointer for Weighted Sum operations on dense vector representations.
+ *          Implements the `y = alpha * a + beta * b` operation.
+ *
+ *  @param[in] a        Pointer to the first data array.
+ *  @param[in] b        Pointer to the second data array.
+ *  @param[in] n        Number of scalar words in the input arrays.
+ *  @param[in] alpha    Scaling factor for the first array.
+ *  @param[in] beta     Scaling factor for the second array.
+ *  @param[out] y       Output value in the same precision as the input arrays.
  */
-typedef void (*simsimd_metric_punned_t)(void const* a, void const* b, simsimd_size_t n, simsimd_distance_t* d);
+typedef void (*simsimd_kernel_wsum_punned_t)(void const *a, void const *b, //
+                                             simsimd_size_t n, simsimd_distance_t alpha, simsimd_distance_t beta,
+                                             void *y);
+
+/**
+ *  @brief  Type-punned function pointer for a SimSIMD public interface.
+ *          Can be a `simsimd_metric_dense_punned_t`, `simsimd_metric_sparse_punned_t`,
+ *          or `simsimd_metric_curved_punned_t`.
+ */
+typedef simsimd_metric_dense_punned_t simsimd_metric_punned_t;
 
 #if SIMSIMD_DYNAMIC_DISPATCH
 SIMSIMD_DYNAMIC simsimd_capability_t simsimd_capabilities(void);
+SIMSIMD_DYNAMIC void simsimd_find_metric_punned( //
+    simsimd_metric_kind_t kind,                  //
+    simsimd_datatype_t datatype,                 //
+    simsimd_capability_t supported,              //
+    simsimd_capability_t allowed,                //
+    simsimd_metric_punned_t *metric_output,      //
+    simsimd_capability_t *capability_output);
 #else
 SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities(void);
+SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
+    simsimd_metric_kind_t kind,                 //
+    simsimd_datatype_t datatype,                //
+    simsimd_capability_t supported,             //
+    simsimd_capability_t allowed,               //
+    simsimd_metric_punned_t *metric_output,     //
+    simsimd_capability_t *capability_output);
 #endif
 
-#if SIMSIMD_TARGET_X86
+#if _SIMSIMD_TARGET_X86
 
 /**
  *  @brief  Function to determine the SIMD capabilities of the current 64-bit x86 machine at @b runtime.
  *  @return A bitmask of the SIMD capabilities represented as a `simsimd_capability_t` enum value.
  */
-SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_x86(void) {
+SIMSIMD_PUBLIC simsimd_capability_t _simsimd_capabilities_x86(void) {
 
     /// The states of 4 registers populated for a specific "cpuid" assembly call
     union four_registers_t {
@@ -276,6 +388,9 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_x86(void) {
     // Check for AVX512BF16 (Function ID 7, Sub-leaf 1, EAX register)
     // https://github.com/llvm/llvm-project/blob/50598f0ff44f3a4e75706f8c53f3380fe7faa896/clang/lib/Headers/cpuid.h#L205
     unsigned supports_avx512bf16 = (info7sub1.named.eax & 0x00000020) != 0;
+    // Clang doesn't show the VP2INTERSECT flag, but we can get it from QEMU
+    // https://stackoverflow.com/a/68289220/2766161
+    unsigned supports_avx512vp2intersect = (info7.named.edx & 0x00000100) != 0;
 
     // Convert specific features into CPU generations
     unsigned supports_haswell = supports_avx2 && supports_f16c && supports_fma;
@@ -284,6 +399,9 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_x86(void) {
                             supports_avx512vbmi2 && supports_avx512vpopcntdq;
     unsigned supports_genoa = supports_avx512bf16;
     unsigned supports_sapphire = supports_avx512fp16;
+    // We don't want to accidently enable AVX512VP2INTERSECT on Intel Tiger Lake CPUs
+    unsigned supports_turin = supports_avx512vp2intersect && supports_avx512bf16;
+    unsigned supports_sierra = 0;
 
     return (simsimd_capability_t)(                     //
         (simsimd_cap_haswell_k * supports_haswell) |   //
@@ -291,16 +409,18 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_x86(void) {
         (simsimd_cap_ice_k * supports_ice) |           //
         (simsimd_cap_genoa_k * supports_genoa) |       //
         (simsimd_cap_sapphire_k * supports_sapphire) | //
+        (simsimd_cap_turin_k * supports_turin) |       //
+        (simsimd_cap_sierra_k * supports_sierra) |     //
         (simsimd_cap_serial_k));
 }
 
-#endif // SIMSIMD_TARGET_X86
+#endif // _SIMSIMD_TARGET_X86
 
-#if SIMSIMD_TARGET_ARM
+#if _SIMSIMD_TARGET_ARM
 
 /*  Compiling the next section one may get: selected processor does not support system register name 'id_aa64zfr0_el1'.
  *  Suppressing assembler errors is very complicated, so when dealing with older ARM CPUs it's simpler to compile this
- *  function targetting newer ones.
+ *  function targeting newer ones.
  */
 #pragma GCC push_options
 #pragma GCC target("arch=armv8.5-a+sve")
@@ -310,19 +430,15 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_x86(void) {
  *  @brief  Function to determine the SIMD capabilities of the current 64-bit Arm machine at @b runtime.
  *  @return A bitmask of the SIMD capabilities represented as a `simsimd_capability_t` enum value.
  */
-SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_arm(void) {
-#if defined(SIMSIMD_DEFINED_APPLE)
+SIMSIMD_PUBLIC simsimd_capability_t _simsimd_capabilities_arm(void) {
+#if defined(_SIMSIMD_DEFINED_APPLE)
     // On Apple Silicon, `mrs` is not allowed in user-space, so we need to use the `sysctl` API.
     uint32_t supports_neon = 0, supports_fp16 = 0, supports_bf16 = 0, supports_i8mm = 0;
     size_t size = sizeof(supports_neon);
-    if (sysctlbyname("hw.optional.neon", &supports_neon, &size, NULL, 0) != 0)
-        supports_neon = 0;
-    if (sysctlbyname("hw.optional.arm.FEAT_FP16", &supports_fp16, &size, NULL, 0) != 0)
-        supports_fp16 = 0;
-    if (sysctlbyname("hw.optional.arm.FEAT_BF16", &supports_bf16, &size, NULL, 0) != 0)
-        supports_bf16 = 0;
-    if (sysctlbyname("hw.optional.arm.FEAT_I8MM", &supports_i8mm, &size, NULL, 0) != 0)
-        supports_i8mm = 0;
+    if (sysctlbyname("hw.optional.neon", &supports_neon, &size, NULL, 0) != 0) supports_neon = 0;
+    if (sysctlbyname("hw.optional.arm.FEAT_FP16", &supports_fp16, &size, NULL, 0) != 0) supports_fp16 = 0;
+    if (sysctlbyname("hw.optional.arm.FEAT_BF16", &supports_bf16, &size, NULL, 0) != 0) supports_bf16 = 0;
+    if (sysctlbyname("hw.optional.arm.FEAT_I8MM", &supports_i8mm, &size, NULL, 0) != 0) supports_i8mm = 0;
 
     return (simsimd_capability_t)(                                     //
         (simsimd_cap_neon_k * (supports_neon)) |                       //
@@ -331,23 +447,7 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_arm(void) {
         (simsimd_cap_neon_i8_k * (supports_neon && supports_i8mm)) |   //
         (simsimd_cap_serial_k));
 
-#elif defined(SIMSIMD_DEFINED_LINUX)
-    // This is how the `arm-cpusysregs` library does it:
-    //
-    //    int ID_AA64ISAR1_EL1_BF16() const { return (int)(_aa64isar1 >> 44) & 0x0F; }
-    //    int ID_AA64ZFR0_EL1_BF16() const { return (int)(_aa64zfr0 >> 20) & 0x0F; }
-    //    int ID_AA64PFR0_EL1_FP() const { return (int)(_aa64pfr0 >> 16) & 0x0F; }
-    //    int ID_AA64ISAR0_EL1_DP() const { return (int)(_aa64isar0 >> 44) & 0x0F; }
-    //    int ID_AA64PFR0_EL1_SVE() const { return (int)(_aa64pfr0 >> 32) & 0x0F; }
-    //    int ID_AA64ZFR0_EL1_SVEver() const { return (int)(_aa64zfr0) & 0x0F; }
-    //    bool FEAT_BF16() const { return ID_AA64ISAR1_EL1_BF16() >= 1 || ID_AA64ZFR0_EL1_BF16() >= 1; }
-    //    bool FEAT_FP16() const { return ID_AA64PFR0_EL1_FP() >= 1 && ID_AA64PFR0_EL1_FP() < 15; }
-    //    bool FEAT_DotProd() const { return ID_AA64ISAR0_EL1_DP() >= 1; }
-    //    bool FEAT_SVE() const { return ID_AA64PFR0_EL1_SVE() >= 1; }
-    //    bool FEAT_SVE2() const { return ID_AA64ZFR0_EL1_SVEver() >= 1; }
-    //    bool FEAT_I8MM() const { return ID_AA64ZFR0_EL1_I8MM() >= 1; }
-    //
-    // https://github.com/lelegard/arm-cpusysregs/tree/4837c62e619a5e5f12bf41b16a1ee1e71d62c76d
+#elif defined(_SIMSIMD_DEFINED_LINUX)
 
     // Read CPUID registers directly
     unsigned long id_aa64isar0_el1 = 0, id_aa64isar1_el1 = 0, id_aa64pfr0_el1 = 0, id_aa64zfr0_el1 = 0;
@@ -377,8 +477,7 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_arm(void) {
 
     // Now let's unpack the status flags from ID_AA64ZFR0_EL1
     // https://developer.arm.com/documentation/ddi0601/2024-03/AArch64-Registers/ID-AA64ZFR0-EL1--SVE-Feature-ID-Register-0?lang=en
-    if (supports_sve)
-        __asm__ __volatile__("mrs %0, ID_AA64ZFR0_EL1" : "=r"(id_aa64zfr0_el1));
+    if (supports_sve) __asm__ __volatile__("mrs %0, ID_AA64ZFR0_EL1" : "=r"(id_aa64zfr0_el1));
     // I8MM, bits [47:44] of ID_AA64ZFR0_EL1
     unsigned supports_sve_i8mm = ((id_aa64zfr0_el1 >> 44) & 0xF) >= 1;
     // BF16, bits [23:20] of ID_AA64ZFR0_EL1
@@ -388,8 +487,8 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_arm(void) {
     //  - 0b0001: SVE2 is implemented
     //  - 0b0010: SVE2.1 is implemented
     // This value must match the existing indicator obtained from ID_AA64PFR0_EL1:
-    //    unsigned supports_sve = ((id_aa64zfr0_el1) & 0xF) >= 1;
-    //    unsigned supports_sve2 = ((id_aa64zfr0_el1) & 0xF) >= 2;
+    unsigned supports_sve2 = ((id_aa64zfr0_el1) & 0xF) >= 1;
+    unsigned supports_sve2p1 = ((id_aa64zfr0_el1) & 0xF) >= 2;
     unsigned supports_neon = 1; // NEON is always supported
 
     return (simsimd_capability_t)(                                                                    //
@@ -401,27 +500,30 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_arm(void) {
         (simsimd_cap_sve_f16_k * (supports_sve && supports_fp16)) |                                   //
         (simsimd_cap_sve_bf16_k * (supports_sve && supports_sve_bf16)) |                              //
         (simsimd_cap_sve_i8_k * (supports_sve && supports_sve_i8mm)) |                                //
+        (simsimd_cap_sve2_k * (supports_sve2)) |                                                      //
+        (simsimd_cap_sve2p1_k * (supports_sve2p1)) |                                                  //
         (simsimd_cap_serial_k));
-#else // SIMSIMD_DEFINED_LINUX
+#else // if !_SIMSIMD_DEFINED_LINUX
     return simsimd_cap_serial_k;
 #endif
 }
 
 #pragma clang attribute pop
 #pragma GCC pop_options
+
 #endif
 
 /**
  *  @brief  Function to determine the SIMD capabilities of the current 64-bit x86 machine at @b runtime.
  *  @return A bitmask of the SIMD capabilities represented as a `simsimd_capability_t` enum value.
  */
-SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_implementation(void) {
-#if SIMSIMD_TARGET_X86
-    return simsimd_capabilities_x86();
-#endif // SIMSIMD_TARGET_X86
-#if SIMSIMD_TARGET_ARM
-    return simsimd_capabilities_arm();
-#endif // SIMSIMD_TARGET_ARM
+SIMSIMD_PUBLIC simsimd_capability_t _simsimd_capabilities_implementation(void) {
+#if _SIMSIMD_TARGET_X86
+    return _simsimd_capabilities_x86();
+#endif // _SIMSIMD_TARGET_X86
+#if _SIMSIMD_TARGET_ARM
+    return _simsimd_capabilities_arm();
+#endif // _SIMSIMD_TARGET_ARM
     return simsimd_cap_serial_k;
 }
 
@@ -430,452 +532,702 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_implementation(void) {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wcast-function-type"
 
-/**
- *  @brief  Determines the best suited metric implementation based on the given datatype,
- *          supported and allowed by hardware capabilities.
- *
- *  @param kind The kind of metric to be evaluated.
- *  @param datatype The data type for which the metric needs to be evaluated.
- *  @param supported The hardware capabilities supported by the CPU.
- *  @param allowed The hardware capabilities allowed for use.
- *  @param metric_output Output variable for the selected similarity function.
- *  @param capability_output Output variable for the utilized hardware capabilities.
- */
-SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
-    simsimd_metric_kind_t kind,                 //
-    simsimd_datatype_t datatype,                //
-    simsimd_capability_t supported,             //
-    simsimd_capability_t allowed,               //
-    simsimd_metric_punned_t* metric_output,     //
-    simsimd_capability_t* capability_output) {
-
-    simsimd_metric_punned_t* m = metric_output;
-    simsimd_capability_t* c = capability_output;
-    simsimd_capability_t viable = (simsimd_capability_t)(supported & allowed);
-    *m = (simsimd_metric_punned_t)0;
-    *c = (simsimd_capability_t)0;
+#ifdef __cplusplus //! option ‘-Wvolatile’ is valid for C++/ObjC++ but not for C
+#pragma GCC diagnostic ignored "-Wvolatile"
+#pragma clang diagnostic ignored "-Wvolatile"
+#endif
 
+SIMSIMD_INTERNAL void _simsimd_find_metric_punned_f64(simsimd_capability_t v, simsimd_metric_kind_t k,
+                                                      simsimd_metric_punned_t *m, simsimd_capability_t *c) {
     typedef simsimd_metric_punned_t m_t;
-    switch (datatype) {
-
-    case simsimd_datatype_unknown_k: break;
-
-    // Double-precision floating-point vectors
-    case simsimd_datatype_f64_k:
-
 #if SIMSIMD_TARGET_SVE
-        if (viable & simsimd_cap_skylake_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f64_sve, *c = simsimd_cap_sve_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f64_sve, *c = simsimd_cap_sve_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f64_sve, *c = simsimd_cap_sve_k; return;
-            default: break;
-            }
+    if (v & simsimd_cap_sve_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f64_sve, *c = simsimd_cap_sve_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f64_sve, *c = simsimd_cap_sve_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f64_sve, *c = simsimd_cap_sve_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f64_sve, *c = simsimd_cap_sve_k; return;
+        default: break;
+        }
+#endif
+#if SIMSIMD_TARGET_NEON
+    if (v & simsimd_cap_neon_k) switch (k) {
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f64_neon, *c = simsimd_cap_neon_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f64_neon, *c = simsimd_cap_neon_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f64_neon, *c = simsimd_cap_neon_k; return;
+        default: break;
+        }
 #endif
 #if SIMSIMD_TARGET_SKYLAKE
-        if (viable & simsimd_cap_skylake_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f64_skylake, *c = simsimd_cap_skylake_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f64_skylake, *c = simsimd_cap_skylake_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f64_skylake, *c = simsimd_cap_skylake_k; return;
-            default: break;
-            }
-#endif
-        if (viable & simsimd_cap_serial_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f64_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f64_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f64_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f64_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f64_serial, *c = simsimd_cap_serial_k; return;
-            default: break;
-            }
-
-        break;
-
-    // Single-precision floating-point vectors
-    case simsimd_datatype_f32_k:
+    if (v & simsimd_cap_skylake_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f64_skylake, *c = simsimd_cap_skylake_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f64_skylake, *c = simsimd_cap_skylake_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f64_skylake, *c = simsimd_cap_skylake_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f64_skylake, *c = simsimd_cap_skylake_k; return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_f64_skylake, *c = simsimd_cap_skylake_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_f64_skylake, *c = simsimd_cap_skylake_k; return;
+        default: break;
+        }
+#endif
+#if SIMSIMD_TARGET_HASWELL
+    if (v & simsimd_cap_haswell_k) switch (k) {
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f64_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f64_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f64_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_f64_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_f64_haswell, *c = simsimd_cap_haswell_k; return;
+        default: break;
+        }
+#endif
+    if (v & simsimd_cap_serial_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f64_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f64_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f64_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f64_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f64_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f64_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_f64_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_mahalanobis_k: *m = (m_t)&simsimd_mahalanobis_f64_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_f64_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_f64_serial, *c = simsimd_cap_serial_k; return;
+        default: break;
+        }
+}
 
+SIMSIMD_INTERNAL void _simsimd_find_metric_punned_f32(simsimd_capability_t v, simsimd_metric_kind_t k,
+                                                      simsimd_metric_punned_t *m, simsimd_capability_t *c) {
+    typedef simsimd_metric_punned_t m_t;
 #if SIMSIMD_TARGET_SVE
-        if (viable & simsimd_cap_sve_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32_sve, *c = simsimd_cap_sve_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f32_sve, *c = simsimd_cap_sve_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f32_sve, *c = simsimd_cap_sve_k; return;
-            default: break;
-            }
+    if (v & simsimd_cap_sve_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32_sve, *c = simsimd_cap_sve_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f32_sve, *c = simsimd_cap_sve_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f32_sve, *c = simsimd_cap_sve_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f32_sve, *c = simsimd_cap_sve_k; return;
+        default: break;
+        }
 #endif
 #if SIMSIMD_TARGET_NEON
-        if (viable & simsimd_cap_neon_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32_neon, *c = simsimd_cap_neon_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f32_neon, *c = simsimd_cap_neon_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f32_neon, *c = simsimd_cap_neon_k; return;
-            case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f32_neon, *c = simsimd_cap_neon_k; return;
-            case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f32_neon, *c = simsimd_cap_neon_k; return;
-            default: break;
-            }
+    if (v & simsimd_cap_neon_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32_neon, *c = simsimd_cap_neon_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f32_neon, *c = simsimd_cap_neon_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f32_neon, *c = simsimd_cap_neon_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f32_neon, *c = simsimd_cap_neon_k; return;
+        case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f32_neon, *c = simsimd_cap_neon_k; return;
+        case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f32_neon, *c = simsimd_cap_neon_k; return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_f32_neon, *c = simsimd_cap_neon_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_f32_neon, *c = simsimd_cap_neon_k; return;
+        default: break;
+        }
 #endif
 #if SIMSIMD_TARGET_SKYLAKE
-        if (viable & simsimd_cap_skylake_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32_skylake, *c = simsimd_cap_skylake_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f32_skylake, *c = simsimd_cap_skylake_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f32_skylake, *c = simsimd_cap_skylake_k; return;
-            case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f32_skylake, *c = simsimd_cap_skylake_k; return;
-            case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f32_skylake, *c = simsimd_cap_skylake_k; return;
-            default: break;
-            }
+    if (v & simsimd_cap_skylake_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32_skylake, *c = simsimd_cap_skylake_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f32_skylake, *c = simsimd_cap_skylake_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f32_skylake, *c = simsimd_cap_skylake_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f32_skylake, *c = simsimd_cap_skylake_k; return;
+        case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f32_skylake, *c = simsimd_cap_skylake_k; return;
+        case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f32_skylake, *c = simsimd_cap_skylake_k; return;
+        case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_f32_skylake, *c = simsimd_cap_skylake_k; return;
+        case simsimd_metric_mahalanobis_k:
+            *m = (m_t)&simsimd_mahalanobis_f32_skylake, *c = simsimd_cap_skylake_k;
+            return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_f32_skylake, *c = simsimd_cap_skylake_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_f32_skylake, *c = simsimd_cap_skylake_k; return;
+        default: break;
+        }
 #endif
 #if SIMSIMD_TARGET_HASWELL
-        if (viable & simsimd_cap_haswell_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32_haswell, *c = simsimd_cap_haswell_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f32_haswell, *c = simsimd_cap_haswell_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f32_haswell, *c = simsimd_cap_haswell_k; return;
-            default: break;
-            }
-#endif
-
-        if (viable & simsimd_cap_serial_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f32_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f32_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f32_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f32_serial, *c = simsimd_cap_serial_k; return;
-            default: break;
-            }
-
-        break;
-
-    // Half-precision floating-point vectors
-    case simsimd_datatype_f16_k:
+    if (v & simsimd_cap_haswell_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f32_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f32_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f32_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_f32_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_f32_haswell, *c = simsimd_cap_haswell_k; return;
+        default: break;
+        }
+#endif
+    if (v & simsimd_cap_serial_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f32_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f32_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f32_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f32_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f32_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_f32_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_mahalanobis_k: *m = (m_t)&simsimd_mahalanobis_f32_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_f32_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_f32_serial, *c = simsimd_cap_serial_k; return;
+        default: break;
+        }
+}
 
-#if SIMSIMD_TARGET_SVE
-        if (viable & simsimd_cap_sve_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16_sve, *c = simsimd_cap_sve_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f16_sve, *c = simsimd_cap_sve_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f16_sve, *c = simsimd_cap_sve_k; return;
-            default: break;
-            }
-#endif
-#if SIMSIMD_TARGET_NEON
-        if (viable & simsimd_cap_neon_f16_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16_neon, *c = simsimd_cap_neon_f16_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f16_neon, *c = simsimd_cap_neon_f16_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f16_neon, *c = simsimd_cap_neon_f16_k; return;
-            case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f16_neon, *c = simsimd_cap_neon_f16_k; return;
-            case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f16_neon, *c = simsimd_cap_neon_f16_k; return;
-            default: break;
-            }
+SIMSIMD_INTERNAL void _simsimd_find_metric_punned_f16(simsimd_capability_t v, simsimd_metric_kind_t k,
+                                                      simsimd_metric_punned_t *m, simsimd_capability_t *c) {
+    typedef simsimd_metric_punned_t m_t;
+#if SIMSIMD_TARGET_SVE_F16
+    if (v & simsimd_cap_sve_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16_sve, *c = simsimd_cap_sve_f16_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f16_sve, *c = simsimd_cap_sve_f16_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f16_sve, *c = simsimd_cap_sve_f16_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f16_sve, *c = simsimd_cap_sve_f16_k; return;
+        default: break;
+        }
+#endif
+#if SIMSIMD_TARGET_NEON_F16
+    if (v & simsimd_cap_neon_f16_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16_neon, *c = simsimd_cap_neon_f16_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f16_neon, *c = simsimd_cap_neon_f16_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f16_neon, *c = simsimd_cap_neon_f16_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f16_neon, *c = simsimd_cap_neon_f16_k; return;
+        case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f16_neon, *c = simsimd_cap_neon_f16_k; return;
+        case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f16_neon, *c = simsimd_cap_neon_f16_k; return;
+        case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_f16_neon, *c = simsimd_cap_neon_f16_k; return;
+        case simsimd_metric_mahalanobis_k: *m = (m_t)&simsimd_mahalanobis_f16_neon, *c = simsimd_cap_neon_f16_k; return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_f16_neon, *c = simsimd_cap_neon_f16_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_f16_neon, *c = simsimd_cap_neon_f16_k; return;
+        default: break;
+        }
 #endif
 #if SIMSIMD_TARGET_SAPPHIRE
-        if (viable & simsimd_cap_sapphire_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
-            case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
-            case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
-            default: break;
-            }
+    if (v & simsimd_cap_sapphire_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
+        case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
+        case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
+        case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
+        case simsimd_metric_mahalanobis_k:
+            *m = (m_t)&simsimd_mahalanobis_f16_sapphire, *c = simsimd_cap_sapphire_k;
+            return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
+        default: break;
+        }
 #endif
 #if SIMSIMD_TARGET_HASWELL
-        if (viable & simsimd_cap_haswell_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16_haswell, *c = simsimd_cap_haswell_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f16_haswell, *c = simsimd_cap_haswell_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f16_haswell, *c = simsimd_cap_haswell_k; return;
-            case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f16_haswell, *c = simsimd_cap_haswell_k; return;
-            case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f16_haswell, *c = simsimd_cap_haswell_k; return;
-            default: break;
-            }
-#endif
-
-        if (viable & simsimd_cap_serial_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f16_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f16_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f16_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f16_serial, *c = simsimd_cap_serial_k; return;
-            default: break;
-            }
-
-        break;
-
-    // Brain floating-point vectors
-    case simsimd_datatype_bf16_k:
-#if SIMSIMD_TARGET_NEON_BF16
-        if (viable & simsimd_cap_neon_bf16_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16_neon, *c = simsimd_cap_neon_bf16_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_bf16_neon, *c = simsimd_cap_neon_bf16_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_bf16_neon, *c = simsimd_cap_neon_bf16_k; return;
-            default: break;
-            }
+    if (v & simsimd_cap_haswell_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f16_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f16_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f16_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f16_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f16_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_f16_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_mahalanobis_k:
+            *m = (m_t)&simsimd_mahalanobis_f16_haswell, *c = simsimd_cap_haswell_k;
+            return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_f16_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_f16_haswell, *c = simsimd_cap_haswell_k; return;
+        default: break;
+        }
+#endif
+    if (v & simsimd_cap_serial_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_f16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_mahalanobis_k: *m = (m_t)&simsimd_mahalanobis_f16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_f16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_f16_serial, *c = simsimd_cap_serial_k; return;
+        default: break;
+        }
+}
+
+SIMSIMD_INTERNAL void _simsimd_find_metric_punned_bf16(simsimd_capability_t v, simsimd_metric_kind_t k,
+                                                       simsimd_metric_punned_t *m, simsimd_capability_t *c) {
+    typedef simsimd_metric_punned_t m_t;
+#if SIMSIMD_TARGET_SVE_BF16
+    if (v & simsimd_cap_sve_bf16_k) switch (k) {
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_bf16_sve, *c = simsimd_cap_sve_bf16_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_bf16_sve, *c = simsimd_cap_sve_bf16_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_bf16_sve, *c = simsimd_cap_sve_bf16_k; return;
+        default: break;
+        }
 #endif
-#if SIMSIMD_TARGET_HASWELL
-        if (viable & simsimd_cap_haswell_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16_haswell, *c = simsimd_cap_haswell_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_bf16_haswell, *c = simsimd_cap_haswell_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_bf16_haswell, *c = simsimd_cap_haswell_k; return;
-            default: break;
-            }
+#if SIMSIMD_TARGET_NEON_BF16
+    if (v & simsimd_cap_neon_bf16_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16_neon, *c = simsimd_cap_neon_bf16_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_bf16_neon, *c = simsimd_cap_neon_bf16_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_bf16_neon, *c = simsimd_cap_neon_bf16_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_bf16_neon, *c = simsimd_cap_neon_bf16_k; return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_bf16_neon, *c = simsimd_cap_neon_bf16_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_bf16_neon, *c = simsimd_cap_neon_bf16_k; return;
+        default: break;
+        }
 #endif
 #if SIMSIMD_TARGET_GENOA
-        if (viable & simsimd_cap_genoa_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16_genoa, *c = simsimd_cap_genoa_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_bf16_genoa, *c = simsimd_cap_genoa_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_bf16_genoa, *c = simsimd_cap_genoa_k; return;
-            default: break;
-            }
-#endif
-        if (viable & simsimd_cap_serial_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_bf16_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_bf16_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_js_k: *m = (m_t)&simsimd_js_bf16_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_bf16_serial, *c = simsimd_cap_serial_k; return;
-            default: break;
-            }
-
-        break;
-
-    // Single-byte integer vectors
-    case simsimd_datatype_i8_k:
-#if SIMSIMD_TARGET_NEON
-        if (viable & simsimd_cap_neon_i8_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_i8_neon, *c = simsimd_cap_neon_i8_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_i8_neon, *c = simsimd_cap_neon_i8_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_i8_neon, *c = simsimd_cap_neon_i8_k; return;
-            default: break;
-            }
+    if (v & simsimd_cap_genoa_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16_genoa, *c = simsimd_cap_genoa_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_bf16_genoa, *c = simsimd_cap_genoa_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_bf16_genoa, *c = simsimd_cap_genoa_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_bf16_genoa, *c = simsimd_cap_genoa_k; return;
+        case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_bf16_genoa, *c = simsimd_cap_genoa_k; return;
+        case simsimd_metric_mahalanobis_k: *m = (m_t)&simsimd_mahalanobis_bf16_genoa, *c = simsimd_cap_genoa_k; return;
+        default: break;
+        }
+#endif
+#if SIMSIMD_TARGET_SKYLAKE
+    if (v & simsimd_cap_skylake_k) switch (k) {
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_bf16_skylake, *c = simsimd_cap_skylake_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_bf16_skylake, *c = simsimd_cap_skylake_k; return;
+        default: break;
+        }
+#endif
+#if SIMSIMD_TARGET_HASWELL
+    if (v & simsimd_cap_haswell_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_bf16_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_bf16_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_bf16_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_bf16_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_mahalanobis_k:
+            *m = (m_t)&simsimd_mahalanobis_bf16_haswell, *c = simsimd_cap_haswell_k;
+            return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_bf16_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_bf16_haswell, *c = simsimd_cap_haswell_k; return;
+        default: break;
+        }
+#endif
+    if (v & simsimd_cap_serial_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_bf16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_bf16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_bf16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_js_k: *m = (m_t)&simsimd_js_bf16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_bf16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_bf16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_mahalanobis_k:
+            *m = (m_t)&simsimd_mahalanobis_bf16_serial, *c = simsimd_cap_serial_k;
+            return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_bf16_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_bf16_serial, *c = simsimd_cap_serial_k; return;
+        default: break;
+        }
+}
+
+SIMSIMD_INTERNAL void _simsimd_find_metric_punned_i8(simsimd_capability_t v, simsimd_metric_kind_t k,
+                                                     simsimd_metric_punned_t *m, simsimd_capability_t *c) {
+    typedef simsimd_metric_punned_t m_t;
+#if SIMSIMD_TARGET_NEON_I8
+    if (v & simsimd_cap_neon_i8_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_i8_neon, *c = simsimd_cap_neon_i8_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_i8_neon, *c = simsimd_cap_neon_i8_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_i8_neon, *c = simsimd_cap_neon_i8_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_i8_neon, *c = simsimd_cap_neon_i8_k; return;
+        default: break;
+        }
+#endif
+#if SIMSIMD_TARGET_NEON_F16 //! Scaling of 8-bit integers is performed using 16-bit floats.
+    if (v & simsimd_cap_neon_f16_k) switch (k) {
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_i8_neon, *c = simsimd_cap_neon_f16_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_i8_neon, *c = simsimd_cap_neon_f16_k; return;
+        default: break;
+        }
+#endif
+#if SIMSIMD_TARGET_SAPPHIRE //! Scaling of 8-bit integers is performed using 16-bit floats.
+    if (v & simsimd_cap_sapphire_k) switch (k) {
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_i8_sapphire, *c = simsimd_cap_sapphire_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_i8_sapphire, *c = simsimd_cap_sapphire_k; return;
+        default: break;
+        }
 #endif
 #if SIMSIMD_TARGET_ICE
-        if (viable & simsimd_cap_ice_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_i8_ice, *c = simsimd_cap_ice_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_i8_ice, *c = simsimd_cap_ice_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_i8_ice, *c = simsimd_cap_ice_k; return;
-            default: break;
-            }
+    if (v & simsimd_cap_ice_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_i8_ice, *c = simsimd_cap_ice_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_i8_ice, *c = simsimd_cap_ice_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_i8_ice, *c = simsimd_cap_ice_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_i8_ice, *c = simsimd_cap_ice_k; return;
+        default: break;
+        }
 #endif
 #if SIMSIMD_TARGET_HASWELL
-        if (viable & simsimd_cap_haswell_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_i8_haswell, *c = simsimd_cap_haswell_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_i8_haswell, *c = simsimd_cap_haswell_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_i8_haswell, *c = simsimd_cap_haswell_k; return;
-            default: break;
-            }
+    if (v & simsimd_cap_haswell_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_i8_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_i8_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_i8_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_i8_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_i8_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_i8_haswell, *c = simsimd_cap_haswell_k; return;
+        default: break;
+        }
+#endif
+    if (v & simsimd_cap_serial_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_i8_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_i8_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_i8_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_i8_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_i8_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_i8_serial, *c = simsimd_cap_serial_k; return;
+        default: break;
+        }
+}
+SIMSIMD_INTERNAL void _simsimd_find_metric_punned_u8(simsimd_capability_t v, simsimd_metric_kind_t k,
+                                                     simsimd_metric_punned_t *m, simsimd_capability_t *c) {
+    typedef simsimd_metric_punned_t m_t;
+#if SIMSIMD_TARGET_NEON_I8
+    if (v & simsimd_cap_neon_i8_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_u8_neon, *c = simsimd_cap_neon_i8_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_u8_neon, *c = simsimd_cap_neon_i8_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_u8_neon, *c = simsimd_cap_neon_i8_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_u8_neon, *c = simsimd_cap_neon_i8_k; return;
+        default: break;
+        }
+#endif
+#if SIMSIMD_TARGET_NEON_F16 //! Scaling of 8-bit integers is performed using 16-bit floats.
+    if (v & simsimd_cap_neon_f16_k) switch (k) {
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_u8_neon, *c = simsimd_cap_neon_f16_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_u8_neon, *c = simsimd_cap_neon_f16_k; return;
+        default: break;
+        }
+#endif
+#if SIMSIMD_TARGET_SAPPHIRE //! Scaling of 8-bit integers is performed using 16-bit floats.
+    if (v & simsimd_cap_sapphire_k) switch (k) {
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_u8_sapphire, *c = simsimd_cap_sapphire_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_u8_sapphire, *c = simsimd_cap_sapphire_k; return;
+        default: break;
+        }
 #endif
+#if SIMSIMD_TARGET_ICE
+    if (v & simsimd_cap_ice_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_u8_ice, *c = simsimd_cap_ice_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_u8_ice, *c = simsimd_cap_ice_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_u8_ice, *c = simsimd_cap_ice_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_u8_ice, *c = simsimd_cap_ice_k; return;
+        default: break;
+        }
+#endif
+#if SIMSIMD_TARGET_HASWELL
+    if (v & simsimd_cap_haswell_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_u8_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_u8_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_u8_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_u8_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_u8_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_u8_haswell, *c = simsimd_cap_haswell_k; return;
+        default: break;
+        }
+#endif
+    if (v & simsimd_cap_serial_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_u8_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_u8_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_u8_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_u8_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_fma_k: *m = (m_t)&simsimd_fma_u8_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_wsum_k: *m = (m_t)&simsimd_wsum_u8_serial, *c = simsimd_cap_serial_k; return;
+        default: break;
+        }
+}
 
-        if (viable & simsimd_cap_serial_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_i8_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_i8_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_i8_serial, *c = simsimd_cap_serial_k; return;
-            default: break;
-            }
-
-        break;
-
-    // Binary vectors
-    case simsimd_datatype_b8_k:
-
+SIMSIMD_INTERNAL void _simsimd_find_metric_punned_b8(simsimd_capability_t v, simsimd_metric_kind_t k,
+                                                     simsimd_metric_punned_t *m, simsimd_capability_t *c) {
+    typedef simsimd_metric_punned_t m_t;
 #if SIMSIMD_TARGET_SVE
-        if (viable & simsimd_cap_sve_k)
-            switch (kind) {
-            case simsimd_metric_hamming_k: *m = (m_t)&simsimd_hamming_b8_sve, *c = simsimd_cap_sve_k; return;
-            case simsimd_metric_jaccard_k: *m = (m_t)&simsimd_jaccard_b8_sve, *c = simsimd_cap_sve_k; return;
-            default: break;
-            }
+    if (v & simsimd_cap_sve_k) switch (k) {
+        case simsimd_metric_hamming_k: *m = (m_t)&simsimd_hamming_b8_sve, *c = simsimd_cap_sve_k; return;
+        case simsimd_metric_jaccard_k: *m = (m_t)&simsimd_jaccard_b8_sve, *c = simsimd_cap_sve_k; return;
+        default: break;
+        }
 #endif
 #if SIMSIMD_TARGET_NEON
-        if (viable & simsimd_cap_neon_k)
-            switch (kind) {
-            case simsimd_metric_hamming_k: *m = (m_t)&simsimd_hamming_b8_neon, *c = simsimd_cap_neon_k; return;
-            case simsimd_metric_jaccard_k: *m = (m_t)&simsimd_jaccard_b8_neon, *c = simsimd_cap_neon_k; return;
-            default: break;
-            }
+    if (v & simsimd_cap_neon_k) switch (k) {
+        case simsimd_metric_hamming_k: *m = (m_t)&simsimd_hamming_b8_neon, *c = simsimd_cap_neon_k; return;
+        case simsimd_metric_jaccard_k: *m = (m_t)&simsimd_jaccard_b8_neon, *c = simsimd_cap_neon_k; return;
+        default: break;
+        }
 #endif
 #if SIMSIMD_TARGET_ICE
-        if (viable & simsimd_cap_ice_k)
-            switch (kind) {
-            case simsimd_metric_hamming_k: *m = (m_t)&simsimd_hamming_b8_ice, *c = simsimd_cap_ice_k; return;
-            case simsimd_metric_jaccard_k: *m = (m_t)&simsimd_jaccard_b8_ice, *c = simsimd_cap_ice_k; return;
-            default: break;
-            }
+    if (v & simsimd_cap_ice_k) switch (k) {
+        case simsimd_metric_hamming_k: *m = (m_t)&simsimd_hamming_b8_ice, *c = simsimd_cap_ice_k; return;
+        case simsimd_metric_jaccard_k: *m = (m_t)&simsimd_jaccard_b8_ice, *c = simsimd_cap_ice_k; return;
+        default: break;
+        }
 #endif
 #if SIMSIMD_TARGET_HASWELL
-        if (viable & simsimd_cap_haswell_k)
-            switch (kind) {
-            case simsimd_metric_hamming_k: *m = (m_t)&simsimd_hamming_b8_haswell, *c = simsimd_cap_haswell_k; return;
-            case simsimd_metric_jaccard_k: *m = (m_t)&simsimd_jaccard_b8_haswell, *c = simsimd_cap_haswell_k; return;
-            default: break;
-            }
-#endif
-
-        if (viable & simsimd_cap_serial_k)
-            switch (kind) {
-            case simsimd_metric_hamming_k: *m = (m_t)&simsimd_hamming_b8_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_jaccard_k: *m = (m_t)&simsimd_jaccard_b8_serial, *c = simsimd_cap_serial_k; return;
-            default: break;
-            }
-
-        break;
+    if (v & simsimd_cap_haswell_k) switch (k) {
+        case simsimd_metric_hamming_k: *m = (m_t)&simsimd_hamming_b8_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_jaccard_k: *m = (m_t)&simsimd_jaccard_b8_haswell, *c = simsimd_cap_haswell_k; return;
+        default: break;
+        }
+#endif
+    if (v & simsimd_cap_serial_k) switch (k) {
+        case simsimd_metric_hamming_k: *m = (m_t)&simsimd_hamming_b8_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_jaccard_k: *m = (m_t)&simsimd_jaccard_b8_serial, *c = simsimd_cap_serial_k; return;
+        default: break;
+        }
+}
 
-    case simsimd_datatype_f32c_k:
+SIMSIMD_INTERNAL void _simsimd_find_metric_punned_f64c(simsimd_capability_t v, simsimd_metric_kind_t k,
+                                                       simsimd_metric_punned_t *m, simsimd_capability_t *c) {
+    typedef simsimd_metric_punned_t m_t;
+#if SIMSIMD_TARGET_SVE
+    if (v & simsimd_cap_sve_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f64c_sve, *c = simsimd_cap_sve_k; return;
+        case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f64c_sve, *c = simsimd_cap_sve_k; return;
+        default: break;
+        }
+#endif
+#if SIMSIMD_TARGET_SKYLAKE
+    if (v & simsimd_cap_skylake_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f64c_skylake, *c = simsimd_cap_skylake_k; return;
+        case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f64c_skylake, *c = simsimd_cap_skylake_k; return;
+        default: break;
+        }
+#endif
+    if (v & simsimd_cap_serial_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f64c_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f64c_serial, *c = simsimd_cap_serial_k; return;
+        default: break;
+        }
+}
 
+SIMSIMD_INTERNAL void _simsimd_find_metric_punned_f32c(simsimd_capability_t v, simsimd_metric_kind_t k,
+                                                       simsimd_metric_punned_t *m, simsimd_capability_t *c) {
+    typedef simsimd_metric_punned_t m_t;
 #if SIMSIMD_TARGET_SVE
-        if (viable & simsimd_cap_sve_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32c_sve, *c = simsimd_cap_sve_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f32c_sve, *c = simsimd_cap_sve_k; return;
-            default: break;
-            }
+    if (v & simsimd_cap_sve_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32c_sve, *c = simsimd_cap_sve_k; return;
+        case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f32c_sve, *c = simsimd_cap_sve_k; return;
+        default: break;
+        }
 #endif
 #if SIMSIMD_TARGET_NEON
-        if (viable & simsimd_cap_neon_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32c_neon, *c = simsimd_cap_neon_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f32c_neon, *c = simsimd_cap_neon_k; return;
-            default: break;
-            }
+    if (v & simsimd_cap_neon_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32c_neon, *c = simsimd_cap_neon_k; return;
+        case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f32c_neon, *c = simsimd_cap_neon_k; return;
+        default: break;
+        }
 #endif
 #if SIMSIMD_TARGET_SKYLAKE
-        if (viable & simsimd_cap_skylake_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32c_skylake, *c = simsimd_cap_skylake_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f32c_skylake, *c = simsimd_cap_skylake_k; return;
-            default: break;
-            }
+    if (v & simsimd_cap_skylake_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32c_skylake, *c = simsimd_cap_skylake_k; return;
+        case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f32c_skylake, *c = simsimd_cap_skylake_k; return;
+        default: break;
+        }
 #endif
 #if SIMSIMD_TARGET_HASWELL
-        if (viable & simsimd_cap_haswell_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32c_haswell, *c = simsimd_cap_haswell_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f32c_haswell, *c = simsimd_cap_haswell_k; return;
-            default: break;
-            }
-#endif
-
-        if (viable & simsimd_cap_serial_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32c_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f32c_serial, *c = simsimd_cap_serial_k; return;
-            default: break;
-            }
-
-        break;
-
-    case simsimd_datatype_f64c_k:
+    if (v & simsimd_cap_haswell_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32c_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f32c_haswell, *c = simsimd_cap_haswell_k; return;
+        default: break;
+        }
+#endif
+    if (v & simsimd_cap_serial_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32c_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f32c_serial, *c = simsimd_cap_serial_k; return;
+        default: break;
+        }
+}
 
-#if SIMSIMD_TARGET_SVE
-        if (viable & simsimd_cap_sve_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f64c_sve, *c = simsimd_cap_sve_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f64c_sve, *c = simsimd_cap_sve_k; return;
-            default: break;
-            }
+SIMSIMD_INTERNAL void _simsimd_find_metric_punned_f16c(simsimd_capability_t v, simsimd_metric_kind_t k,
+                                                       simsimd_metric_punned_t *m, simsimd_capability_t *c) {
+    typedef simsimd_metric_punned_t m_t;
+#if SIMSIMD_TARGET_SVE_F16
+    if (v & simsimd_cap_sve_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16c_sve, *c = simsimd_cap_sve_f16_k; return;
+        case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f16c_sve, *c = simsimd_cap_sve_f16_k; return;
+        default: break;
+        }
+#endif
+#if SIMSIMD_TARGET_NEON_F16
+    if (v & simsimd_cap_neon_f16_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16c_neon, *c = simsimd_cap_neon_f16_k; return;
+        case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f16c_neon, *c = simsimd_cap_neon_f16_k; return;
+        default: break;
+        }
 #endif
-#if SIMSIMD_TARGET_SKYLAKE
-        if (viable & simsimd_cap_skylake_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f64c_skylake, *c = simsimd_cap_skylake_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f64c_skylake, *c = simsimd_cap_skylake_k; return;
-            default: break;
-            }
+#if SIMSIMD_TARGET_SAPPHIRE
+    if (v & simsimd_cap_sapphire_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16c_sapphire, *c = simsimd_cap_sapphire_k; return;
+        case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f16c_sapphire, *c = simsimd_cap_sapphire_k; return;
+        default: break;
+        }
 #endif
+#if SIMSIMD_TARGET_HASWELL
+    if (v & simsimd_cap_haswell_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16c_haswell, *c = simsimd_cap_haswell_k; return;
+        case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f16c_haswell, *c = simsimd_cap_haswell_k; return;
+        default: break;
+        }
+#endif
+    if (v & simsimd_cap_serial_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16c_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f16c_serial, *c = simsimd_cap_serial_k; return;
+        default: break;
+        }
+}
 
-        if (viable & simsimd_cap_serial_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f64c_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f64c_serial, *c = simsimd_cap_serial_k; return;
-            default: break;
-            }
-
-        break;
+SIMSIMD_INTERNAL void _simsimd_find_metric_punned_bf16c(simsimd_capability_t v, simsimd_metric_kind_t k,
+                                                        simsimd_metric_punned_t *m, simsimd_capability_t *c) {
+    typedef simsimd_metric_punned_t m_t;
+#if SIMSIMD_TARGET_NEON_BF16
+    if (v & simsimd_cap_neon_bf16_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16c_neon, *c = simsimd_cap_neon_bf16_k; return;
+        case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_bf16c_neon, *c = simsimd_cap_neon_bf16_k; return;
+        default: break;
+        }
+#endif
+#if SIMSIMD_TARGET_GENOA
+    if (v & simsimd_cap_genoa_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16c_genoa, *c = simsimd_cap_genoa_k; return;
+        case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_bf16c_genoa, *c = simsimd_cap_genoa_k; return;
+        default: break;
+        }
+#endif
+    if (v & simsimd_cap_serial_k) switch (k) {
+        case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16c_serial, *c = simsimd_cap_serial_k; return;
+        case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_bf16c_serial, *c = simsimd_cap_serial_k; return;
+        default: break;
+        }
+}
 
-    case simsimd_datatype_f16c_k:
+SIMSIMD_INTERNAL void _simsimd_find_metric_punned_u16(simsimd_capability_t v, simsimd_metric_kind_t k,
+                                                      simsimd_metric_punned_t *m, simsimd_capability_t *c) {
+    typedef simsimd_metric_punned_t m_t;
+#if SIMSIMD_TARGET_SVE2
+    if (v & simsimd_cap_sve2_k) switch (k) {
+        case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u16_sve2, *c = simsimd_cap_sve2_k; return;
+        case simsimd_metric_spdot_counts_k: *m = (m_t)&simsimd_spdot_counts_u16_sve2, *c = simsimd_cap_sve2_k; return;
+#if SIMSIMD_TARGET_SVE_BF16 //! We also need `bf16` support for weights
+        case simsimd_metric_spdot_weights_k: *m = (m_t)&simsimd_spdot_weights_u16_sve2, *c = simsimd_cap_sve2_k; return;
+#endif
+        default: break;
+        }
+#endif
+#if SIMSIMD_TARGET_NEON
+    if (v & simsimd_cap_neon_k) switch (k) {
+        case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u16_neon, *c = simsimd_cap_neon_k; return;
+        default: break;
+        }
+#endif
+#if SIMSIMD_TARGET_TURIN
+    if (v & simsimd_cap_turin_k) switch (k) {
+        case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u16_turin, *c = simsimd_cap_turin_k; return;
+        case simsimd_metric_spdot_counts_k: *m = (m_t)&simsimd_spdot_counts_u16_turin, *c = simsimd_cap_turin_k; return;
+        case simsimd_metric_spdot_weights_k:
+            *m = (m_t)&simsimd_spdot_weights_u16_turin, *c = simsimd_cap_turin_k;
+            return;
+        default: break;
+        }
+#endif
+#if SIMSIMD_TARGET_ICE
+    if (v & simsimd_cap_ice_k) switch (k) {
+        case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u16_ice, *c = simsimd_cap_skylake_k; return;
+        default: break;
+        }
+#endif
+    if (v & simsimd_cap_serial_k) switch (k) {
+        case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u16_serial, *c = simsimd_cap_serial_k; return;
+        default: break;
+        }
+}
 
-#if SIMSIMD_TARGET_SVE
-        if (viable & simsimd_cap_sve_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16c_sve, *c = simsimd_cap_sve_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f16c_sve, *c = simsimd_cap_sve_k; return;
-            default: break;
-            }
+SIMSIMD_INTERNAL void _simsimd_find_metric_punned_u32(simsimd_capability_t v, simsimd_metric_kind_t k,
+                                                      simsimd_metric_punned_t *m, simsimd_capability_t *c) {
+    typedef simsimd_metric_punned_t m_t;
+#if SIMSIMD_TARGET_SVE2
+    if (v & simsimd_cap_sve2_k) switch (k) {
+        case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u32_sve2, *c = simsimd_cap_sve2_k; return;
+        default: break;
+        }
 #endif
 #if SIMSIMD_TARGET_NEON
-        if (viable & simsimd_cap_neon_f16_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16c_neon, *c = simsimd_cap_neon_f16_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f16c_neon, *c = simsimd_cap_neon_f16_k; return;
-            default: break;
-            }
+    if (v & simsimd_cap_neon_k) switch (k) {
+        case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u32_neon, *c = simsimd_cap_neon_k; return;
+        default: break;
+        }
 #endif
-#if SIMSIMD_TARGET_SAPPHIRE
-        if (viable & simsimd_cap_sapphire_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16c_sapphire, *c = simsimd_cap_sapphire_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f16c_sapphire, *c = simsimd_cap_sapphire_k; return;
-            default: break;
-            }
+#if SIMSIMD_TARGET_TURIN
+    if (v & simsimd_cap_turin_k) switch (k) {
+        case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u32_turin, *c = simsimd_cap_skylake_k; return;
+        default: break;
+        }
 #endif
-#if SIMSIMD_TARGET_HASWELL
-        if (viable & simsimd_cap_haswell_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16c_haswell, *c = simsimd_cap_haswell_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f16c_haswell, *c = simsimd_cap_haswell_k; return;
-            default: break;
-            }
+#if SIMSIMD_TARGET_ICE
+    if (v & simsimd_cap_ice_k) switch (k) {
+        case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u32_ice, *c = simsimd_cap_skylake_k; return;
+        default: break;
+        }
+#endif
+    if (v & simsimd_cap_serial_k) switch (k) {
+        case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u32_serial, *c = simsimd_cap_serial_k; return;
+        default: break;
+        }
+}
+
+/**
+ *  @brief  Determines the best suited metric implementation based on the given datatype,
+ *          supported and allowed by hardware capabilities.
+ *
+ *  @param kind The kind of metric to be evaluated.
+ *  @param datatype The data type for which the metric needs to be evaluated.
+ *  @param supported The hardware capabilities supported by the CPU.
+ *  @param allowed The hardware capabilities allowed for use.
+ *  @param metric_output Output variable for the selected similarity function.
+ *  @param capability_output Output variable for the utilized hardware capabilities.
+ */
+SIMSIMD_INTERNAL void _simsimd_find_metric_punned_implementation( //
+    simsimd_metric_kind_t kind,                                   //
+    simsimd_datatype_t datatype,                                  //
+    simsimd_capability_t supported,                               //
+    simsimd_capability_t allowed,                                 //
+    simsimd_metric_punned_t *metric_output,                       //
+    simsimd_capability_t *capability_output) {
+
+    // Modern compilers abso-freaking-lutely love optimizing-out my logic!
+    // Just marking the variables as `volatile` is not enough, so we have
+    // to add inline assembly to further discourage them!
+#if defined(_MSC_VER)
+    _ReadWriteBarrier();
+#else
+    __asm__ __volatile__("" ::: "memory");
 #endif
 
-        if (viable & simsimd_cap_serial_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16c_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f16c_serial, *c = simsimd_cap_serial_k; return;
-            default: break;
-            }
+    simsimd_metric_punned_t *m = metric_output;
+    simsimd_capability_t *c = capability_output;
+    simsimd_capability_t viable = (simsimd_capability_t)(supported & allowed);
 
-        break;
-    case simsimd_datatype_bf16c_k:
+    switch (datatype) {
 
-#if SIMSIMD_TARGET_NEON_BF16
-        if (viable & simsimd_cap_neon_bf16_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16c_neon, *c = simsimd_cap_neon_bf16_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_bf16c_neon, *c = simsimd_cap_neon_bf16_k; return;
-            default: break;
-            }
-#endif
-#if SIMSIMD_TARGET_GENOA
-        if (viable & simsimd_cap_genoa_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16c_genoa, *c = simsimd_cap_genoa_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_bf16c_genoa, *c = simsimd_cap_genoa_k; return;
-            default: break;
-            }
-#endif
-
-        if (viable & simsimd_cap_serial_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16c_serial, *c = simsimd_cap_serial_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_bf16c_serial, *c = simsimd_cap_serial_k; return;
-            default: break;
-            }
-
-        break;
+    case simsimd_datatype_f64_k: _simsimd_find_metric_punned_f64(viable, kind, m, c); return;
+    case simsimd_datatype_f32_k: _simsimd_find_metric_punned_f32(viable, kind, m, c); return;
+    case simsimd_datatype_f16_k: _simsimd_find_metric_punned_f16(viable, kind, m, c); return;
+    case simsimd_datatype_bf16_k: _simsimd_find_metric_punned_bf16(viable, kind, m, c); return;
+    case simsimd_datatype_i8_k: _simsimd_find_metric_punned_i8(viable, kind, m, c); return;
+    case simsimd_datatype_u8_k: _simsimd_find_metric_punned_u8(viable, kind, m, c); return;
+    case simsimd_datatype_b8_k: _simsimd_find_metric_punned_b8(viable, kind, m, c); return;
+    case simsimd_datatype_f32c_k: _simsimd_find_metric_punned_f32c(viable, kind, m, c); return;
+    case simsimd_datatype_f64c_k: _simsimd_find_metric_punned_f64c(viable, kind, m, c); return;
+    case simsimd_datatype_f16c_k: _simsimd_find_metric_punned_f16c(viable, kind, m, c); return;
+    case simsimd_datatype_bf16c_k: _simsimd_find_metric_punned_bf16c(viable, kind, m, c); return;
+    case simsimd_datatype_u16_k: _simsimd_find_metric_punned_u16(viable, kind, m, c); return;
+    case simsimd_datatype_u32_k: _simsimd_find_metric_punned_u32(viable, kind, m, c); return;
+
+    // These data-types are not supported yet
+    case simsimd_datatype_i4x2_k: break;
+    case simsimd_datatype_i16_k: break;
+    case simsimd_datatype_i32_k: break;
+    case simsimd_datatype_i64_k: break;
+    case simsimd_datatype_u64_k: break;
+    case simsimd_datatype_unknown_k: break;
+    default: break;
     }
+
+    // Replace with zeros if no suitable implementation was found
+    *m = (simsimd_metric_punned_t)0;
+    *c = (simsimd_capability_t)0;
+
+    // Modern compilers abso-freaking-lutely love optimizing-out my logic!
+    // Just marking the variables as `volatile` is not enough, so we have
+    // to add inline assembly to further discourage them!
+#if defined(_MSC_VER)
+    _ReadWriteBarrier();
+#else
+    __asm__ __volatile__("" ::: "memory");
+#endif
 }
 
 #pragma GCC diagnostic pop
@@ -910,10 +1262,14 @@ SIMSIMD_PUBLIC simsimd_metric_punned_t simsimd_metric_punned( //
  *  - Check if the CPU supports AVX512F and AVX512BW extensions on Skylake x86 CPUs and newer
  *  - Check if the CPU supports AVX512VNNI, AVX512IFMA, AVX512BITALG, AVX512VBMI2, and AVX512VPOPCNTDQ
  *    extensions on Ice Lake x86 CPUs and newer
+ *  - Check if the CPU supports AVX512BF16 extensions on Genoa x86 CPUs and newer
  *  - Check if the CPU supports AVX512FP16 extensions on Sapphire Rapids x86 CPUs and newer
+ *  - Check if the CPU supports AVX2VP2INTERSECT extensions on Turin x86 CPUs and newer
  *
  *  @return 1 if the CPU supports the SIMD instruction set, 0 otherwise.
  */
+SIMSIMD_DYNAMIC simsimd_capability_t simsimd_capabilities(void);
+SIMSIMD_DYNAMIC int simsimd_uses_dynamic_dispatch(void);
 SIMSIMD_DYNAMIC int simsimd_uses_neon(void);
 SIMSIMD_DYNAMIC int simsimd_uses_neon_f16(void);
 SIMSIMD_DYNAMIC int simsimd_uses_neon_bf16(void);
@@ -922,12 +1278,14 @@ SIMSIMD_DYNAMIC int simsimd_uses_sve(void);
 SIMSIMD_DYNAMIC int simsimd_uses_sve_f16(void);
 SIMSIMD_DYNAMIC int simsimd_uses_sve_bf16(void);
 SIMSIMD_DYNAMIC int simsimd_uses_sve_i8(void);
+SIMSIMD_DYNAMIC int simsimd_uses_sve2(void);
 SIMSIMD_DYNAMIC int simsimd_uses_haswell(void);
 SIMSIMD_DYNAMIC int simsimd_uses_skylake(void);
 SIMSIMD_DYNAMIC int simsimd_uses_ice(void);
-SIMSIMD_DYNAMIC int simsimd_uses_sapphire(void);
 SIMSIMD_DYNAMIC int simsimd_uses_genoa(void);
-SIMSIMD_DYNAMIC simsimd_capability_t simsimd_capabilities(void);
+SIMSIMD_DYNAMIC int simsimd_uses_sapphire(void);
+SIMSIMD_DYNAMIC int simsimd_uses_turin(void);
+SIMSIMD_DYNAMIC int simsimd_uses_sierra(void);
 
 /*  Inner products
  *  - Dot product: the sum of the products of the corresponding elements of two vectors.
@@ -943,30 +1301,30 @@ SIMSIMD_DYNAMIC simsimd_capability_t simsimd_capabilities(void);
  *  @note The dot product is zero if and only if the two vectors are orthogonal.
  *  @note Defined only for floating-point and integer data types.
  */
-SIMSIMD_DYNAMIC void simsimd_dot_f16(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_dot_bf16(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_size_t n,
-                                      simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_dot_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_dot_f64(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_dot_f16c(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                      simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_dot_bf16c(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_size_t n,
-                                       simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_dot_f32c(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                      simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_dot_f64c(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n,
-                                      simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_vdot_f16c(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                       simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_vdot_bf16c(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_size_t n,
-                                        simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_vdot_f32c(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                       simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_vdot_f64c(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n,
-                                       simsimd_distance_t* d);
+SIMSIMD_DYNAMIC void simsimd_dot_f16(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_dot_bf16(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                      simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_dot_f32(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_dot_f64(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_dot_f16c(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                      simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_dot_bf16c(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                       simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_dot_f32c(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                      simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_dot_f64c(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                      simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_vdot_f16c(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                       simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_vdot_bf16c(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                        simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_vdot_f32c(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                       simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_vdot_f64c(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                       simsimd_distance_t *d);
 
 /*  Spatial distances
  *  - Cosine distance: the cosine of the angle between two vectors.
@@ -981,26 +1339,42 @@ SIMSIMD_DYNAMIC void simsimd_vdot_f64c(simsimd_f64_t const* a, simsimd_f64_t con
  *  @note The output distance value is zero if and only if the two vectors are identical.
  *  @note Defined only for floating-point and integer data types.
  */
-SIMSIMD_DYNAMIC void simsimd_cos_i8(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_cos_f16(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_cos_bf16(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_size_t n,
-                                      simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_cos_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_cos_f64(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_l2sq_i8(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_l2sq_f16(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                      simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_l2sq_bf16(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_size_t n,
-                                       simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_l2sq_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                      simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_l2sq_f64(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n,
-                                      simsimd_distance_t* d);
+SIMSIMD_DYNAMIC void simsimd_cos_i8(simsimd_i8_t const *a, simsimd_i8_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_cos_u8(simsimd_u8_t const *a, simsimd_u8_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_cos_f16(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_cos_bf16(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                      simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_cos_f32(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_cos_f64(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_l2sq_i8(simsimd_i8_t const *a, simsimd_i8_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_l2sq_u8(simsimd_u8_t const *a, simsimd_u8_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_l2sq_f16(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                      simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_l2sq_bf16(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                       simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_l2sq_f32(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                      simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_l2sq_f64(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                      simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_l2_i8(simsimd_i8_t const *a, simsimd_i8_t const *b, simsimd_size_t n,
+                                   simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_l2_u8(simsimd_u8_t const *a, simsimd_u8_t const *b, simsimd_size_t n,
+                                   simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_l2_f16(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_l2_bf16(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_l2_f32(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_l2_f64(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d);
 
 /*  Binary distances
  *  - Hamming distance: the number of positions at which the corresponding bits are different.
@@ -1015,18 +1389,18 @@ SIMSIMD_DYNAMIC void simsimd_l2sq_f64(simsimd_f64_t const* a, simsimd_f64_t cons
  *  @note The output distance value is zero if and only if the two vectors are identical.
  *  @note Defined only for binary data.
  */
-SIMSIMD_DYNAMIC void simsimd_hamming_b8(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n,
-                                        simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_jaccard_b8(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n,
-                                        simsimd_distance_t* d);
+SIMSIMD_DYNAMIC void simsimd_hamming_b8(simsimd_b8_t const *a, simsimd_b8_t const *b, simsimd_size_t n,
+                                        simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_jaccard_b8(simsimd_b8_t const *a, simsimd_b8_t const *b, simsimd_size_t n,
+                                        simsimd_distance_t *d);
 
 /*  Probability distributions
  *  - Jensen-Shannon divergence: a measure of similarity between two probability distributions.
  *  - Kullback-Leibler divergence: a measure of how one probability distribution diverges from a second.
  *
- *  @param a The first descrete probability distribution.
- *  @param b The second descrete probability distribution.
- *  @param n The number of elements in the descrete distributions.
+ *  @param a The first discrete probability distribution.
+ *  @param b The second discrete probability distribution.
+ *  @param n The number of elements in the discrete distributions.
  *  @param d The output divergence value.
  *
  *  @note The distributions are assumed to be normalized.
@@ -1034,22 +1408,22 @@ SIMSIMD_DYNAMIC void simsimd_jaccard_b8(simsimd_b8_t const* a, simsimd_b8_t cons
  *  @note The output divergence value is zero if and only if the two distributions are identical.
  *  @note Defined only for floating-point data types.
  */
-SIMSIMD_DYNAMIC void simsimd_kl_f16(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_kl_bf16(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_kl_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_kl_f64(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_js_f16(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_js_bf16(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_js_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d);
-SIMSIMD_DYNAMIC void simsimd_js_f64(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d);
+SIMSIMD_DYNAMIC void simsimd_kl_f16(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_kl_bf16(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_kl_f32(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_kl_f64(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_js_f16(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_js_bf16(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_js_f32(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d);
+SIMSIMD_DYNAMIC void simsimd_js_f64(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d);
 
 #else
 
@@ -1066,20 +1440,33 @@ SIMSIMD_DYNAMIC void simsimd_js_f64(simsimd_f64_t const* a, simsimd_f64_t const*
  */
 
 // clang-format off
-SIMSIMD_PUBLIC int simsimd_uses_neon(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_NEON; }
-SIMSIMD_PUBLIC int simsimd_uses_neon_f16(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_NEON && SIMSIMD_NATIVE_F16; }
-SIMSIMD_PUBLIC int simsimd_uses_neon_bf16(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_NEON && SIMSIMD_NATIVE_BF16; }
-SIMSIMD_PUBLIC int simsimd_uses_neon_i8(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_NEON; }
-SIMSIMD_PUBLIC int simsimd_uses_sve(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE; }
-SIMSIMD_PUBLIC int simsimd_uses_sve_f16(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE && SIMSIMD_NATIVE_F16; }
-SIMSIMD_PUBLIC int simsimd_uses_sve_bf16(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE && SIMSIMD_NATIVE_BF16; }
-SIMSIMD_PUBLIC int simsimd_uses_sve_i8(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE; }
-SIMSIMD_PUBLIC int simsimd_uses_haswell(void) { return SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_HASWELL; }
-SIMSIMD_PUBLIC int simsimd_uses_skylake(void) { return SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_SKYLAKE; }
-SIMSIMD_PUBLIC int simsimd_uses_ice(void) { return SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_ICE; }
-SIMSIMD_PUBLIC int simsimd_uses_sapphire(void) { return SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_SAPPHIRE; }
-SIMSIMD_PUBLIC int simsimd_uses_genoa(void) { return SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_GENOA; }
-SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities(void) { return simsimd_capabilities_implementation(); }
+SIMSIMD_PUBLIC int simsimd_uses_neon(void) { return _SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_NEON; }
+SIMSIMD_PUBLIC int simsimd_uses_neon_f16(void) { return _SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_NEON_F16 ; }
+SIMSIMD_PUBLIC int simsimd_uses_neon_bf16(void) { return _SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_NEON_BF16; }
+SIMSIMD_PUBLIC int simsimd_uses_neon_i8(void) { return _SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_NEON_I8; }
+SIMSIMD_PUBLIC int simsimd_uses_sve(void) { return _SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE; }
+SIMSIMD_PUBLIC int simsimd_uses_sve_f16(void) { return _SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE_F16; }
+SIMSIMD_PUBLIC int simsimd_uses_sve_bf16(void) { return _SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE_BF16; }
+SIMSIMD_PUBLIC int simsimd_uses_sve_i8(void) { return _SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE_I8; }
+SIMSIMD_PUBLIC int simsimd_uses_sve2(void) { return _SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE2; }
+SIMSIMD_PUBLIC int simsimd_uses_haswell(void) { return _SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_HASWELL; }
+SIMSIMD_PUBLIC int simsimd_uses_skylake(void) { return _SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_SKYLAKE; }
+SIMSIMD_PUBLIC int simsimd_uses_ice(void) { return _SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_ICE; }
+SIMSIMD_PUBLIC int simsimd_uses_genoa(void) { return _SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_GENOA; }
+SIMSIMD_PUBLIC int simsimd_uses_sapphire(void) { return _SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_SAPPHIRE; }
+SIMSIMD_PUBLIC int simsimd_uses_turin(void) { return _SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_TURIN; }
+SIMSIMD_PUBLIC int simsimd_uses_sierra(void) { return _SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_SIERRA; }
+SIMSIMD_PUBLIC int simsimd_uses_dynamic_dispatch(void) { return 0; }
+SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities(void) { return _simsimd_capabilities_implementation(); }
+SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
+    simsimd_metric_kind_t kind,                 //
+    simsimd_datatype_t datatype,                //
+    simsimd_capability_t supported,             //
+    simsimd_capability_t allowed,               //
+    simsimd_metric_punned_t* metric_output,     //
+    simsimd_capability_t* capability_output) {
+    _simsimd_find_metric_punned_implementation(kind, datatype, supported, allowed, metric_output, capability_output);
+}
 // clang-format on
 
 /*  Inner products
@@ -1096,11 +1483,35 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities(void) { return simsimd_
  *  @note The dot product is zero if and only if the two vectors are orthogonal.
  *  @note Defined only for floating-point and integer data types.
  */
-SIMSIMD_PUBLIC void simsimd_dot_f16(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d) {
-#if SIMSIMD_TARGET_SVE
+SIMSIMD_PUBLIC void simsimd_dot_i8(simsimd_i8_t const *a, simsimd_i8_t const *b, simsimd_size_t n,
+                                   simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_NEON_F16
+    simsimd_dot_i8_neon(a, b, n, d);
+#elif SIMSIMD_TARGET_ICE
+    simsimd_dot_i8_ice(a, b, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_dot_i8_haswell(a, b, n, d);
+#else
+    simsimd_dot_i8_serial(a, b, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_dot_u8(simsimd_u8_t const *a, simsimd_u8_t const *b, simsimd_size_t n,
+                                   simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_NEON_F16
+    simsimd_dot_u8_neon(a, b, n, d);
+#elif SIMSIMD_TARGET_ICE
+    simsimd_dot_u8_ice(a, b, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_dot_u8_haswell(a, b, n, d);
+#else
+    simsimd_dot_u8_serial(a, b, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_dot_f16(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_SVE_F16
     simsimd_dot_f16_sve(a, b, n, d);
-#elif SIMSIMD_TARGET_NEON
+#elif SIMSIMD_TARGET_NEON_F16
     simsimd_dot_f16_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_SAPPHIRE
     simsimd_dot_f16_sapphire(a, b, n, d);
@@ -1110,20 +1521,20 @@ SIMSIMD_PUBLIC void simsimd_dot_f16(simsimd_f16_t const* a, simsimd_f16_t const*
     simsimd_dot_f16_serial(a, b, n, d);
 #endif
 }
-
-SIMSIMD_PUBLIC void simsimd_dot_bf16(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_dot_bf16(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_GENOA
     simsimd_dot_bf16_genoa(a, b, n, d);
 #elif SIMSIMD_TARGET_HASWELL
     simsimd_dot_bf16_haswell(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON_BF16
+    simsimd_dot_bf16_neon(a, b, n, d);
 #else
     simsimd_dot_bf16_serial(a, b, n, d);
 #endif
 }
-
-SIMSIMD_PUBLIC void simsimd_dot_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_dot_f32(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_SVE
     simsimd_dot_f32_sve(a, b, n, d);
 #elif SIMSIMD_TARGET_NEON
@@ -1136,8 +1547,8 @@ SIMSIMD_PUBLIC void simsimd_dot_f32(simsimd_f32_t const* a, simsimd_f32_t const*
     simsimd_dot_f32_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_dot_f64(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_dot_f64(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_SVE
     simsimd_dot_f64_sve(a, b, n, d);
 #elif SIMSIMD_TARGET_SKYLAKE
@@ -1146,11 +1557,11 @@ SIMSIMD_PUBLIC void simsimd_dot_f64(simsimd_f64_t const* a, simsimd_f64_t const*
     simsimd_dot_f64_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_dot_f16c(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d) {
-#if SIMSIMD_TARGET_SVE
+SIMSIMD_PUBLIC void simsimd_dot_f16c(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_SVE_F16
     simsimd_dot_f16c_sve(a, b, n, d);
-#elif SIMSIMD_TARGET_NEON
+#elif SIMSIMD_TARGET_NEON_F16
     simsimd_dot_f16c_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_SAPPHIRE
     simsimd_dot_f16c_sapphire(a, b, n, d);
@@ -1160,16 +1571,18 @@ SIMSIMD_PUBLIC void simsimd_dot_f16c(simsimd_f16_t const* a, simsimd_f16_t const
     simsimd_dot_f16c_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_dot_bf16c(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_size_t n,
-                                      simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_dot_bf16c(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                      simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_GENOA
     simsimd_dot_bf16c_genoa(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON_BF16
+    simsimd_dot_bf16c_neon(a, b, n, d);
 #else
     simsimd_dot_bf16c_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_dot_f32c(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_dot_f32c(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_SVE
     simsimd_dot_f32c_sve(a, b, n, d);
 #elif SIMSIMD_TARGET_NEON
@@ -1182,8 +1595,8 @@ SIMSIMD_PUBLIC void simsimd_dot_f32c(simsimd_f32_t const* a, simsimd_f32_t const
     simsimd_dot_f32c_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_dot_f64c(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_dot_f64c(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_SVE
     simsimd_dot_f64c_sve(a, b, n, d);
 #elif SIMSIMD_TARGET_SKYLAKE
@@ -1192,8 +1605,8 @@ SIMSIMD_PUBLIC void simsimd_dot_f64c(simsimd_f64_t const* a, simsimd_f64_t const
     simsimd_dot_f64c_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_vdot_f16c(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                      simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_vdot_f16c(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                      simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_SVE
     simsimd_vdot_f16c_sve(a, b, n, d);
 #elif SIMSIMD_TARGET_NEON
@@ -1206,12 +1619,18 @@ SIMSIMD_PUBLIC void simsimd_vdot_f16c(simsimd_f16_t const* a, simsimd_f16_t cons
     simsimd_vdot_f16c_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_vdot_bf16c(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_size_t n,
-                                       simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_vdot_bf16c(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                       simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_GENOA
+    simsimd_vdot_bf16c_genoa(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON_BF16
+    simsimd_dot_bf16c_neon(a, b, n, d);
+#else
     simsimd_vdot_bf16c_serial(a, b, n, d);
+#endif
 }
-SIMSIMD_PUBLIC void simsimd_vdot_f32c(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                      simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_vdot_f32c(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                      simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_SVE
     simsimd_vdot_f32c_sve(a, b, n, d);
 #elif SIMSIMD_TARGET_NEON
@@ -1224,8 +1643,8 @@ SIMSIMD_PUBLIC void simsimd_vdot_f32c(simsimd_f32_t const* a, simsimd_f32_t cons
     simsimd_vdot_f32c_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_vdot_f64c(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n,
-                                      simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_vdot_f64c(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                      simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_SVE
     simsimd_vdot_f64c_sve(a, b, n, d);
 #elif SIMSIMD_TARGET_SKYLAKE
@@ -1248,8 +1667,8 @@ SIMSIMD_PUBLIC void simsimd_vdot_f64c(simsimd_f64_t const* a, simsimd_f64_t cons
  *  @note The output distance value is zero if and only if the two vectors are identical.
  *  @note Defined only for floating-point and integer data types.
  */
-SIMSIMD_PUBLIC void simsimd_cos_i8(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t n,
-                                   simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_cos_i8(simsimd_i8_t const *a, simsimd_i8_t const *b, simsimd_size_t n,
+                                   simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_NEON
     simsimd_cos_i8_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_ICE
@@ -1260,23 +1679,23 @@ SIMSIMD_PUBLIC void simsimd_cos_i8(simsimd_i8_t const* a, simsimd_i8_t const* b,
     simsimd_cos_i8_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_l2sq_i8(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_cos_u8(simsimd_u8_t const *a, simsimd_u8_t const *b, simsimd_size_t n,
+                                   simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_NEON
-    simsimd_l2sq_i8_neon(a, b, n, d);
+    simsimd_cos_u8_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_ICE
-    simsimd_l2sq_i8_ice(a, b, n, d);
+    simsimd_cos_u8_ice(a, b, n, d);
 #elif SIMSIMD_TARGET_HASWELL
-    simsimd_l2sq_i8_haswell(a, b, n, d);
+    simsimd_cos_u8_haswell(a, b, n, d);
 #else
-    simsimd_l2sq_i8_serial(a, b, n, d);
+    simsimd_cos_u8_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_cos_f16(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d) {
-#if SIMSIMD_TARGET_SVE
+SIMSIMD_PUBLIC void simsimd_cos_f16(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_SVE_F16
     simsimd_cos_f16_sve(a, b, n, d);
-#elif SIMSIMD_TARGET_NEON
+#elif SIMSIMD_TARGET_NEON_F16
     simsimd_cos_f16_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_SAPPHIRE
     simsimd_cos_f16_sapphire(a, b, n, d);
@@ -1286,18 +1705,22 @@ SIMSIMD_PUBLIC void simsimd_cos_f16(simsimd_f16_t const* a, simsimd_f16_t const*
     simsimd_cos_f16_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_cos_bf16(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_cos_bf16(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_GENOA
     simsimd_cos_bf16_genoa(a, b, n, d);
 #elif SIMSIMD_TARGET_HASWELL
     simsimd_cos_bf16_haswell(a, b, n, d);
+#elif SIMSIMD_TARGET_SVE_BF16
+    simsimd_cos_bf16_sve(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON_BF16
+    simsimd_cos_bf16_neon(a, b, n, d);
 #else
     simsimd_cos_bf16_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_cos_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_cos_f32(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_SVE
     simsimd_cos_f32_sve(a, b, n, d);
 #elif SIMSIMD_TARGET_NEON
@@ -1310,21 +1733,47 @@ SIMSIMD_PUBLIC void simsimd_cos_f32(simsimd_f32_t const* a, simsimd_f32_t const*
     simsimd_cos_f32_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_cos_f64(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_cos_f64(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_SVE
     simsimd_cos_f64_sve(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_cos_f64_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_SKYLAKE
     simsimd_cos_f64_skylake(a, b, n, d);
 #else
     simsimd_cos_f64_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_l2sq_f16(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d) {
-#if SIMSIMD_TARGET_SVE
+SIMSIMD_PUBLIC void simsimd_l2sq_i8(simsimd_i8_t const *a, simsimd_i8_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_NEON
+    simsimd_l2sq_i8_neon(a, b, n, d);
+#elif SIMSIMD_TARGET_ICE
+    simsimd_l2sq_i8_ice(a, b, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_l2sq_i8_haswell(a, b, n, d);
+#else
+    simsimd_l2sq_i8_serial(a, b, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_l2sq_u8(simsimd_u8_t const *a, simsimd_u8_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_NEON
+    simsimd_l2sq_u8_neon(a, b, n, d);
+#elif SIMSIMD_TARGET_ICE
+    simsimd_l2sq_u8_ice(a, b, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_l2sq_u8_haswell(a, b, n, d);
+#else
+    simsimd_l2sq_u8_serial(a, b, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_l2sq_f16(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_SVE_F16
     simsimd_l2sq_f16_sve(a, b, n, d);
-#elif SIMSIMD_TARGET_NEON
+#elif SIMSIMD_TARGET_NEON_F16
     simsimd_l2sq_f16_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_SAPPHIRE
     simsimd_l2sq_f16_sapphire(a, b, n, d);
@@ -1334,18 +1783,22 @@ SIMSIMD_PUBLIC void simsimd_l2sq_f16(simsimd_f16_t const* a, simsimd_f16_t const
     simsimd_l2sq_f16_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_l2sq_bf16(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_size_t n,
-                                      simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_l2sq_bf16(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                      simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_GENOA
     simsimd_l2sq_bf16_genoa(a, b, n, d);
 #elif SIMSIMD_TARGET_HASWELL
     simsimd_l2sq_bf16_haswell(a, b, n, d);
+#elif SIMSIMD_TARGET_SVE_BF16
+    simsimd_l2sq_bf16_sve(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON_BF16
+    simsimd_l2sq_bf16_neon(a, b, n, d);
 #else
     simsimd_l2sq_bf16_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_l2sq_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_l2sq_f32(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_SVE
     simsimd_l2sq_f32_sve(a, b, n, d);
 #elif SIMSIMD_TARGET_NEON
@@ -1358,16 +1811,96 @@ SIMSIMD_PUBLIC void simsimd_l2sq_f32(simsimd_f32_t const* a, simsimd_f32_t const
     simsimd_l2sq_f32_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_l2sq_f64(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n,
-                                     simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_l2sq_f64(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_SVE
     simsimd_l2sq_f64_sve(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_l2sq_f64_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_SKYLAKE
     simsimd_l2sq_f64_skylake(a, b, n, d);
 #else
     simsimd_l2sq_f64_serial(a, b, n, d);
 #endif
 }
+SIMSIMD_PUBLIC void simsimd_l2_i8(simsimd_i8_t const *a, simsimd_i8_t const *b, simsimd_size_t n,
+                                  simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_NEON
+    simsimd_l2_i8_neon(a, b, n, d);
+#elif SIMSIMD_TARGET_ICE
+    simsimd_l2_i8_ice(a, b, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_l2_i8_haswell(a, b, n, d);
+#else
+    simsimd_l2_i8_serial(a, b, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_l2_u8(simsimd_u8_t const *a, simsimd_u8_t const *b, simsimd_size_t n,
+                                  simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_NEON
+    simsimd_l2_u8_neon(a, b, n, d);
+#elif SIMSIMD_TARGET_ICE
+    simsimd_l2_u8_ice(a, b, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_l2_u8_haswell(a, b, n, d);
+#else
+    simsimd_l2_u8_serial(a, b, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_l2_f16(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                   simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_SVE_F16
+    simsimd_l2_f16_sve(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON_F16
+    simsimd_l2_f16_neon(a, b, n, d);
+#elif SIMSIMD_TARGET_SAPPHIRE
+    simsimd_l2_f16_sapphire(a, b, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_l2_f16_haswell(a, b, n, d);
+#else
+    simsimd_l2_f16_serial(a, b, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_l2_bf16(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_GENOA
+    simsimd_l2_bf16_genoa(a, b, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_l2_bf16_haswell(a, b, n, d);
+#elif SIMSIMD_TARGET_SVE_BF16
+    simsimd_l2_bf16_sve(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON_BF16
+    simsimd_l2_bf16_neon(a, b, n, d);
+#else
+    simsimd_l2_bf16_serial(a, b, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_l2_f32(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                   simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_SVE
+    simsimd_l2_f32_sve(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_l2_f32_neon(a, b, n, d);
+#elif SIMSIMD_TARGET_SKYLAKE
+    simsimd_l2_f32_skylake(a, b, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_l2_f32_haswell(a, b, n, d);
+#else
+    simsimd_l2_f32_serial(a, b, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_l2_f64(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                   simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_SVE
+    simsimd_l2_f64_sve(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_l2_f64_neon(a, b, n, d);
+#elif SIMSIMD_TARGET_SKYLAKE
+    simsimd_l2_f64_skylake(a, b, n, d);
+#else
+    simsimd_l2_f64_serial(a, b, n, d);
+#endif
+}
 
 /*  Binary distances
  *  - Hamming distance: the number of positions at which the corresponding bits are different.
@@ -1382,8 +1915,8 @@ SIMSIMD_PUBLIC void simsimd_l2sq_f64(simsimd_f64_t const* a, simsimd_f64_t const
  *  @note The output distance value is zero if and only if the two vectors are identical.
  *  @note Defined only for binary data.
  */
-SIMSIMD_PUBLIC void simsimd_hamming_b8(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n,
-                                       simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_hamming_b8(simsimd_b8_t const *a, simsimd_b8_t const *b, simsimd_size_t n,
+                                       simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_SVE
     simsimd_hamming_b8_sve(a, b, n, d);
 #elif SIMSIMD_TARGET_NEON
@@ -1396,8 +1929,8 @@ SIMSIMD_PUBLIC void simsimd_hamming_b8(simsimd_b8_t const* a, simsimd_b8_t const
     simsimd_hamming_b8_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_jaccard_b8(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n,
-                                       simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_jaccard_b8(simsimd_b8_t const *a, simsimd_b8_t const *b, simsimd_size_t n,
+                                       simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_SVE
     simsimd_jaccard_b8_sve(a, b, n, d);
 #elif SIMSIMD_TARGET_NEON
@@ -1415,9 +1948,9 @@ SIMSIMD_PUBLIC void simsimd_jaccard_b8(simsimd_b8_t const* a, simsimd_b8_t const
  *  - Jensen-Shannon divergence: a measure of similarity between two probability distributions.
  *  - Kullback-Leibler divergence: a measure of how one probability distribution diverges from a second.
  *
- *  @param a The first descrete probability distribution.
- *  @param b The second descrete probability distribution.
- *  @param n The number of elements in the descrete distributions.
+ *  @param a The first discrete probability distribution.
+ *  @param b The second discrete probability distribution.
+ *  @param n The number of elements in the discrete distributions.
  *  @param d The output divergence value.
  *
  *  @note The distributions are assumed to be normalized.
@@ -1425,8 +1958,8 @@ SIMSIMD_PUBLIC void simsimd_jaccard_b8(simsimd_b8_t const* a, simsimd_b8_t const
  *  @note The output divergence value is zero if and only if the two distributions are identical.
  *  @note Defined only for floating-point data types.
  */
-SIMSIMD_PUBLIC void simsimd_kl_f16(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                   simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_kl_f16(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                   simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_NEON
     simsimd_kl_f16_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_HASWELL
@@ -1435,12 +1968,12 @@ SIMSIMD_PUBLIC void simsimd_kl_f16(simsimd_f16_t const* a, simsimd_f16_t const*
     simsimd_kl_f16_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_kl_bf16(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_kl_bf16(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d) {
     simsimd_kl_bf16_serial(a, b, n, d);
 }
-SIMSIMD_PUBLIC void simsimd_kl_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                   simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_kl_f32(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                   simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_NEON
     simsimd_kl_f32_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_SKYLAKE
@@ -1449,12 +1982,12 @@ SIMSIMD_PUBLIC void simsimd_kl_f32(simsimd_f32_t const* a, simsimd_f32_t const*
     simsimd_kl_f32_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_kl_f64(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n,
-                                   simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_kl_f64(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                   simsimd_distance_t *d) {
     simsimd_kl_f64_serial(a, b, n, d);
 }
-SIMSIMD_PUBLIC void simsimd_js_f16(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                   simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_js_f16(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                   simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_NEON
     simsimd_js_f16_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_HASWELL
@@ -1463,12 +1996,12 @@ SIMSIMD_PUBLIC void simsimd_js_f16(simsimd_f16_t const* a, simsimd_f16_t const*
     simsimd_js_f16_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_js_bf16(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_js_bf16(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t *d) {
     simsimd_js_bf16_serial(a, b, n, d);
 }
-SIMSIMD_PUBLIC void simsimd_js_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                   simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_js_f32(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                   simsimd_distance_t *d) {
 #if SIMSIMD_TARGET_NEON
     simsimd_js_f32_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_SKYLAKE
@@ -1477,11 +2010,337 @@ SIMSIMD_PUBLIC void simsimd_js_f32(simsimd_f32_t const* a, simsimd_f32_t const*
     simsimd_js_f32_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_js_f64(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n,
-                                   simsimd_distance_t* d) {
+SIMSIMD_PUBLIC void simsimd_js_f64(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                   simsimd_distance_t *d) {
     simsimd_js_f64_serial(a, b, n, d);
 }
 
+/*  Set operations
+ *
+ *  @param a The first sorted array of integers.
+ *  @param b The second sorted array of integers.
+ *  @param a_length The number of elements in the first array.
+ *  @param b_length The number of elements in the second array.
+ *  @param d The output for the number of elements in the intersection.
+ */
+SIMSIMD_PUBLIC void simsimd_intersect_u16(simsimd_u16_t const *a, simsimd_u16_t const *b, simsimd_size_t a_length,
+                                          simsimd_size_t b_length, simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_SVE2
+    simsimd_intersect_u16_sve2(a, b, a_length, b_length, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_intersect_u16_neon(a, b, a_length, b_length, d);
+#elif SIMSIMD_TARGET_TURIN
+    simsimd_intersect_u16_turin(a, b, a_length, b_length, d);
+#elif SIMSIMD_TARGET_ICE
+    simsimd_intersect_u16_ice(a, b, a_length, b_length, d);
+#else
+    simsimd_intersect_u16_serial(a, b, a_length, b_length, d);
+#endif
+}
+
+SIMSIMD_PUBLIC void simsimd_intersect_u32(simsimd_u32_t const *a, simsimd_u32_t const *b, simsimd_size_t a_length,
+                                          simsimd_size_t b_length, simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_SVE2
+    simsimd_intersect_u32_sve2(a, b, a_length, b_length, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_intersect_u32_neon(a, b, a_length, b_length, d);
+#elif SIMSIMD_TARGET_TURIN
+    simsimd_intersect_u32_turin(a, b, a_length, b_length, d);
+#elif SIMSIMD_TARGET_ICE
+    simsimd_intersect_u32_ice(a, b, a_length, b_length, d);
+#else
+    simsimd_intersect_u32_serial(a, b, a_length, b_length, d);
+#endif
+}
+
+/*  Weighted set operations
+ *
+ *  @param a The first sorted array of integers.
+ *  @param b The second sorted array of integers.
+ *  @param a_weights The weights for the first array.
+ *  @param b_weights The weights for the second array.
+ *  @param a_length The number of elements in the first array.
+ *  @param b_length The number of elements in the second array.
+ *  @param d The output for the number of elements in the intersection.
+ */
+SIMSIMD_PUBLIC void simsimd_spdot_counts_u16(simsimd_u16_t const *a, simsimd_u16_t const *b,
+                                             simsimd_i16_t const *a_weights, simsimd_i16_t const *b_weights,
+                                             simsimd_size_t a_length, simsimd_size_t b_length, simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_SVE2
+    simsimd_spdot_counts_u16_sve2(a, b, a_weights, b_weights, a_length, b_length, d);
+#elif SIMSIMD_TARGET_TURIN
+    simsimd_spdot_counts_u16_turin(a, b, a_weights, b_weights, a_length, b_length, d);
+#else
+    simsimd_spdot_counts_u16_serial(a, b, a_weights, b_weights, a_length, b_length, d);
+#endif
+}
+
+SIMSIMD_PUBLIC void simsimd_spdot_weights_u16(simsimd_u16_t const *a, simsimd_u16_t const *b,
+                                              simsimd_bf16_t const *a_weights, simsimd_bf16_t const *b_weights,
+                                              simsimd_size_t a_length, simsimd_size_t b_length, simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_SVE2
+    simsimd_spdot_weights_u16_sve2(a, b, a_weights, b_weights, a_length, b_length, d);
+#elif SIMSIMD_TARGET_TURIN
+    simsimd_spdot_weights_u16_turin(a, b, a_weights, b_weights, a_length, b_length, d);
+#else
+    simsimd_spdot_weights_u16_serial(a, b, a_weights, b_weights, a_length, b_length, d);
+#endif
+}
+
+/*  Curved space distances
+ *
+ *  @param a The first vector of floating point values.
+ *  @param b The second vector of floating point values.
+ *  @param c The metric tensor or covariance matrix.
+ *  @param n The number of dimensions in the vectors.
+ *  @param d The output for the number of elements in the intersection.
+ */
+SIMSIMD_PUBLIC void simsimd_bilinear_f64(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_f64_t const *c,
+                                         simsimd_size_t n, simsimd_distance_t *d) {
+
+    simsimd_bilinear_f64_serial(a, b, c, n, d);
+}
+SIMSIMD_PUBLIC void simsimd_mahalanobis_f64(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_f64_t const *c,
+                                            simsimd_size_t n, simsimd_distance_t *d) {
+    simsimd_mahalanobis_f64_serial(a, b, c, n, d);
+}
+SIMSIMD_PUBLIC void simsimd_bilinear_f32(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_f32_t const *c,
+                                         simsimd_size_t n, simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_SKYLAKE
+    simsimd_bilinear_f32_skylake(a, b, c, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_bilinear_f32_neon(a, b, c, n, d);
+#else
+    simsimd_bilinear_f32_serial(a, b, c, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_mahalanobis_f32(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_f32_t const *c,
+                                            simsimd_size_t n, simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_SKYLAKE
+    simsimd_mahalanobis_f32_skylake(a, b, c, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_mahalanobis_f32_neon(a, b, c, n, d);
+#else
+    simsimd_mahalanobis_f32_serial(a, b, c, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_bilinear_f16(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_f16_t const *c,
+                                         simsimd_size_t n, simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_SAPPHIRE
+    simsimd_bilinear_f16_sapphire(a, b, c, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_bilinear_f16_haswell(a, b, c, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_bilinear_f16_neon(a, b, c, n, d);
+#else
+    simsimd_bilinear_f16_serial(a, b, c, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_mahalanobis_f16(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_f16_t const *c,
+                                            simsimd_size_t n, simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_SAPPHIRE
+    simsimd_mahalanobis_f16_sapphire(a, b, c, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_mahalanobis_f16_haswell(a, b, c, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_mahalanobis_f16_neon(a, b, c, n, d);
+#else
+    simsimd_mahalanobis_f16_serial(a, b, c, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_bilinear_bf16(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_bf16_t const *c,
+                                          simsimd_size_t n, simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_GENOA
+    simsimd_bilinear_bf16_genoa(a, b, c, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_bilinear_bf16_haswell(a, b, c, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_bilinear_bf16_neon(a, b, c, n, d);
+#else
+    simsimd_bilinear_bf16_serial(a, b, c, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_mahalanobis_bf16(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_bf16_t const *c,
+                                             simsimd_size_t n, simsimd_distance_t *d) {
+#if SIMSIMD_TARGET_GENOA
+    simsimd_mahalanobis_bf16_genoa(a, b, c, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_mahalanobis_bf16_haswell(a, b, c, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_mahalanobis_bf16_neon(a, b, c, n, d);
+#else
+    simsimd_mahalanobis_bf16_serial(a, b, c, n, d);
+#endif
+}
+
+/*  Elementwise operations
+ *
+ *  @param a The first vector of integral or floating point values.
+ *  @param b The second vector of integral or floating point values.
+ *  @param c The third vector of integral or floating point values.
+ *  @param n The number of dimensions in the vectors.
+ *  @param alpha The first scaling factor.
+ *  @param beta The first scaling factor.
+ *  @param r The output vector or integral or floating point values.
+ */
+SIMSIMD_PUBLIC void simsimd_wsum_f64(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t alpha, simsimd_distance_t beta, simsimd_f64_t *r) {
+#if SIMSIMD_TARGET_SKYLAKE
+    simsimd_wsum_f64_skylake(a, b, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_wsum_f64_haswell(a, b, n, alpha, beta, r);
+#else
+    simsimd_wsum_f64_serial(a, b, n, alpha, beta, r);
+#endif
+}
+
+SIMSIMD_PUBLIC void simsimd_wsum_f32(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t alpha, simsimd_distance_t beta, simsimd_f32_t *r) {
+#if SIMSIMD_TARGET_SKYLAKE
+    simsimd_wsum_f32_skylake(a, b, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_wsum_f32_haswell(a, b, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_wsum_f32_neon(a, b, n, alpha, beta, r);
+#else
+    simsimd_wsum_f32_serial(a, b, n, alpha, beta, r);
+#endif
+}
+
+SIMSIMD_PUBLIC void simsimd_wsum_bf16(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_size_t n,
+                                      simsimd_distance_t alpha, simsimd_distance_t beta, simsimd_bf16_t *r) {
+#if SIMSIMD_TARGET_SKYLAKE
+    simsimd_wsum_bf16_skylake(a, b, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_wsum_bf16_haswell(a, b, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_wsum_bf16_neon(a, b, n, alpha, beta, r);
+#else
+    simsimd_wsum_bf16_serial(a, b, n, alpha, beta, r);
+#endif
+}
+
+SIMSIMD_PUBLIC void simsimd_wsum_f16(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                     simsimd_distance_t alpha, simsimd_distance_t beta, simsimd_f16_t *r) {
+#if SIMSIMD_TARGET_SAPPHIRE
+    simsimd_wsum_f16_sapphire(a, b, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_wsum_f16_haswell(a, b, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_NEON_F16
+    simsimd_wsum_f16_neon(a, b, n, alpha, beta, r);
+#else
+    simsimd_wsum_f16_serial(a, b, n, alpha, beta, r);
+#endif
+}
+
+SIMSIMD_PUBLIC void simsimd_wsum_i8(simsimd_i8_t const *a, simsimd_i8_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t alpha, simsimd_distance_t beta, simsimd_i8_t *r) {
+#if SIMSIMD_TARGET_SAPPHIRE
+    simsimd_wsum_i8_sapphire(a, b, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_wsum_i8_haswell(a, b, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_NEON_F16
+    simsimd_wsum_i8_neon(a, b, n, alpha, beta, r);
+#else
+    simsimd_wsum_i8_serial(a, b, n, alpha, beta, r);
+#endif
+}
+
+SIMSIMD_PUBLIC void simsimd_wsum_u8(simsimd_u8_t const *a, simsimd_u8_t const *b, simsimd_size_t n,
+                                    simsimd_distance_t alpha, simsimd_distance_t beta, simsimd_u8_t *r) {
+#if SIMSIMD_TARGET_SAPPHIRE
+    simsimd_wsum_u8_sapphire(a, b, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_wsum_u8_haswell(a, b, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_NEON_F16
+    simsimd_wsum_u8_neon(a, b, n, alpha, beta, r);
+#else
+    simsimd_wsum_u8_serial(a, b, n, alpha, beta, r);
+#endif
+}
+
+SIMSIMD_PUBLIC void simsimd_fma_f64(simsimd_f64_t const *a, simsimd_f64_t const *b, simsimd_f64_t const *c,
+                                    simsimd_size_t n, simsimd_distance_t alpha, simsimd_distance_t beta,
+                                    simsimd_f64_t *r) {
+#if SIMSIMD_TARGET_SKYLAKE
+    simsimd_fma_f64_skylake(a, b, c, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_fma_f64_haswell(a, b, c, n, alpha, beta, r);
+#else
+    simsimd_fma_f64_serial(a, b, c, n, alpha, beta, r);
+#endif
+}
+
+SIMSIMD_PUBLIC void simsimd_fma_f32(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_f32_t const *c,
+                                    simsimd_size_t n, simsimd_distance_t alpha, simsimd_distance_t beta,
+                                    simsimd_f32_t *r) {
+#if SIMSIMD_TARGET_SKYLAKE
+    simsimd_fma_f32_skylake(a, b, c, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_fma_f32_haswell(a, b, c, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_fma_f32_neon(a, b, c, n, alpha, beta, r);
+#else
+    simsimd_fma_f32_serial(a, b, c, n, alpha, beta, r);
+#endif
+}
+
+SIMSIMD_PUBLIC void simsimd_fma_bf16(simsimd_bf16_t const *a, simsimd_bf16_t const *b, simsimd_bf16_t const *c,
+                                     simsimd_size_t n, simsimd_distance_t alpha, simsimd_distance_t beta,
+                                     simsimd_bf16_t *r) {
+#if SIMSIMD_TARGET_SKYLAKE
+    simsimd_fma_bf16_skylake(a, b, c, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_fma_bf16_haswell(a, b, c, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_fma_bf16_neon(a, b, c, n, alpha, beta, r);
+#else
+    simsimd_fma_bf16_serial(a, b, c, n, alpha, beta, r);
+#endif
+}
+
+SIMSIMD_PUBLIC void simsimd_fma_f16(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_f16_t const *c,
+                                    simsimd_size_t n, simsimd_distance_t alpha, simsimd_distance_t beta,
+                                    simsimd_f16_t *r) {
+#if SIMSIMD_TARGET_SAPPHIRE
+    simsimd_fma_f16_sapphire(a, b, c, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_fma_f16_haswell(a, b, c, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_NEON_F16
+    simsimd_fma_f16_neon(a, b, c, n, alpha, beta, r);
+#else
+    simsimd_fma_f16_serial(a, b, c, n, alpha, beta, r);
+#endif
+}
+
+SIMSIMD_PUBLIC void simsimd_fma_i8(simsimd_i8_t const *a, simsimd_i8_t const *b, simsimd_i8_t const *c,
+                                   simsimd_size_t n, simsimd_distance_t alpha, simsimd_distance_t beta,
+                                   simsimd_i8_t *r) {
+#if SIMSIMD_TARGET_SAPPHIRE
+    simsimd_fma_i8_sapphire(a, b, c, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_fma_i8_haswell(a, b, c, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_NEON_F16
+    simsimd_fma_i8_neon(a, b, c, n, alpha, beta, r);
+#else
+    simsimd_fma_i8_serial(a, b, c, n, alpha, beta, r);
+#endif
+}
+
+SIMSIMD_PUBLIC void simsimd_fma_u8(simsimd_u8_t const *a, simsimd_u8_t const *b, simsimd_u8_t const *c,
+                                   simsimd_size_t n, simsimd_distance_t alpha, simsimd_distance_t beta,
+                                   simsimd_u8_t *r) {
+#if SIMSIMD_TARGET_SAPPHIRE
+    simsimd_fma_u8_sapphire(a, b, c, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_fma_u8_haswell(a, b, c, n, alpha, beta, r);
+#elif SIMSIMD_TARGET_NEON_F16
+    simsimd_fma_u8_neon(a, b, c, n, alpha, beta, r);
+#else
+    simsimd_fma_u8_serial(a, b, c, n, alpha, beta, r);
+#endif
+}
+
 #endif
 
 #ifdef __cplusplus