numkong 7.0.0 → 7.4.1

package/include/numkong/geospatial/v128relaxed.h

@@ -46,46 +46,50 @@ extern "C" {
  *  These require WASM trigonometric kernels from trigonometry/v128relaxed.h.
  */
 
-NK_INTERNAL v128_t nk_haversine_f64x2_v128relaxed_(  //
-    v128_t first_latitudes, v128_t first_longitudes, //
-    v128_t second_latitudes, v128_t second_longitudes) {
+NK_INTERNAL v128_t nk_haversine_f64x2_v128relaxed_(              //
+    v128_t first_latitudes_f64x2, v128_t first_longitudes_f64x2, //
+    v128_t second_latitudes_f64x2, v128_t second_longitudes_f64x2) {
 
-    v128_t const earth_radius = wasm_f64x2_splat(NK_EARTH_MEDIATORIAL_RADIUS);
-    v128_t const half = wasm_f64x2_splat(0.5);
-    v128_t const one = wasm_f64x2_splat(1.0);
-    v128_t const two = wasm_f64x2_splat(2.0);
+    v128_t const earth_radius_f64x2 = wasm_f64x2_splat(NK_EARTH_MEDIATORIAL_RADIUS);
+    v128_t const half_f64x2 = wasm_f64x2_splat(0.5);
+    v128_t const one_f64x2 = wasm_f64x2_splat(1.0);
+    v128_t const two_f64x2 = wasm_f64x2_splat(2.0);
 
-    v128_t latitude_delta = wasm_f64x2_sub(second_latitudes, first_latitudes);
-    v128_t longitude_delta = wasm_f64x2_sub(second_longitudes, first_longitudes);
+    v128_t latitude_delta_f64x2 = wasm_f64x2_sub(second_latitudes_f64x2, first_latitudes_f64x2);
+    v128_t longitude_delta_f64x2 = wasm_f64x2_sub(second_longitudes_f64x2, first_longitudes_f64x2);
 
     // Haversine terms: sin^2(delta/2)
-    v128_t latitude_delta_half = wasm_f64x2_mul(latitude_delta, half);
-    v128_t longitude_delta_half = wasm_f64x2_mul(longitude_delta, half);
-    v128_t sin_latitude_delta_half = nk_f64x2_sin_v128relaxed_(latitude_delta_half);
-    v128_t sin_longitude_delta_half = nk_f64x2_sin_v128relaxed_(longitude_delta_half);
-    v128_t sin_squared_latitude_delta_half = wasm_f64x2_mul(sin_latitude_delta_half, sin_latitude_delta_half);
-    v128_t sin_squared_longitude_delta_half = wasm_f64x2_mul(sin_longitude_delta_half, sin_longitude_delta_half);
+    v128_t latitude_delta_half_f64x2 = wasm_f64x2_mul(latitude_delta_f64x2, half_f64x2);
+    v128_t longitude_delta_half_f64x2 = wasm_f64x2_mul(longitude_delta_f64x2, half_f64x2);
+    v128_t sin_latitude_delta_half_f64x2 = nk_f64x2_sin_v128relaxed_(latitude_delta_half_f64x2);
+    v128_t sin_longitude_delta_half_f64x2 = nk_f64x2_sin_v128relaxed_(longitude_delta_half_f64x2);
+    v128_t sin_squared_latitude_delta_half_f64x2 = wasm_f64x2_mul(sin_latitude_delta_half_f64x2,
+                                                                  sin_latitude_delta_half_f64x2);
+    v128_t sin_squared_longitude_delta_half_f64x2 = wasm_f64x2_mul(sin_longitude_delta_half_f64x2,
+                                                                   sin_longitude_delta_half_f64x2);
 
     // Latitude cosine product
-    v128_t cos_first_latitude = nk_f64x2_cos_v128relaxed_(first_latitudes);
-    v128_t cos_second_latitude = nk_f64x2_cos_v128relaxed_(second_latitudes);
-    v128_t cos_latitude_product = wasm_f64x2_mul(cos_first_latitude, cos_second_latitude);
+    v128_t cos_first_latitude_f64x2 = nk_f64x2_cos_v128relaxed_(first_latitudes_f64x2);
+    v128_t cos_second_latitude_f64x2 = nk_f64x2_cos_v128relaxed_(second_latitudes_f64x2);
+    v128_t cos_latitude_product_f64x2 = wasm_f64x2_mul(cos_first_latitude_f64x2, cos_second_latitude_f64x2);
 
     // a = sin^2(dlat/2) + cos(lat1) * cos(lat2) * sin^2(dlon/2)
-    v128_t haversine_term = wasm_f64x2_add(sin_squared_latitude_delta_half,
-                                           wasm_f64x2_mul(cos_latitude_product, sin_squared_longitude_delta_half));
-    // Clamp haversine_term to [0, 1] to prevent NaN from sqrt of negative values
-    // relaxed_min/max: 1 instruction (minpd/maxpd) vs 6-9 (with NaN/signed-zero fixup) on x86.
-    // Safe because haversine_term is a product of finite sin/cos values — NaN is impossible.
-    v128_t zero = wasm_f64x2_splat(0.0);
-    haversine_term = wasm_f64x2_relaxed_max(zero, wasm_f64x2_relaxed_min(one, haversine_term));
+    v128_t haversine_term_f64x2 = wasm_f64x2_add(
+        sin_squared_latitude_delta_half_f64x2,
+        wasm_f64x2_mul(cos_latitude_product_f64x2, sin_squared_longitude_delta_half_f64x2));
+    // Clamp haversine_term_f64x2 to [0, 1] to prevent NaN from sqrt of negative values
+    // relaxed_min/max: 1 instruction (minpd/maxpd) vs 6-9 (with NaN/signed-zero_f64x2 fixup) on x86.
+    // Safe because haversine_term_f64x2 is a product of finite sin/cos values — NaN is impossible.
+    v128_t zero_f64x2 = wasm_f64x2_splat(0.0);
+    haversine_term_f64x2 = wasm_f64x2_relaxed_max(zero_f64x2, wasm_f64x2_relaxed_min(one_f64x2, haversine_term_f64x2));
 
     // Central angle: c = 2 * atan2(sqrt(a), sqrt(1-a))
-    v128_t sqrt_haversine = wasm_f64x2_sqrt(haversine_term);
-    v128_t sqrt_complement = wasm_f64x2_sqrt(wasm_f64x2_sub(one, haversine_term));
-    v128_t central_angle = wasm_f64x2_mul(two, nk_f64x2_atan2_v128relaxed_(sqrt_haversine, sqrt_complement));
+    v128_t sqrt_haversine_f64x2 = wasm_f64x2_sqrt(haversine_term_f64x2);
+    v128_t sqrt_complement_f64x2 = wasm_f64x2_sqrt(wasm_f64x2_sub(one_f64x2, haversine_term_f64x2));
+    v128_t central_angle_f64x2 = wasm_f64x2_mul(
+        two_f64x2, nk_f64x2_atan2_v128relaxed_(sqrt_haversine_f64x2, sqrt_complement_f64x2));
 
-    return wasm_f64x2_mul(earth_radius, central_angle);
+    return wasm_f64x2_mul(earth_radius_f64x2, central_angle_f64x2);
 }
 
 NK_PUBLIC void nk_haversine_f64_v128relaxed(        //
@@ -94,14 +98,14 @@ NK_PUBLIC void nk_haversine_f64_v128relaxed(        //
     nk_size_t n, nk_f64_t *results) {
 
     while (n >= 2) {
-        v128_t first_latitudes = wasm_v128_load(a_lats);
-        v128_t first_longitudes = wasm_v128_load(a_lons);
-        v128_t second_latitudes = wasm_v128_load(b_lats);
-        v128_t second_longitudes = wasm_v128_load(b_lons);
+        v128_t first_latitudes_f64x2 = wasm_v128_load(a_lats);
+        v128_t first_longitudes_f64x2 = wasm_v128_load(a_lons);
+        v128_t second_latitudes_f64x2 = wasm_v128_load(b_lats);
+        v128_t second_longitudes_f64x2 = wasm_v128_load(b_lons);
 
-        v128_t distances = nk_haversine_f64x2_v128relaxed_(first_latitudes, first_longitudes, second_latitudes,
-                                                           second_longitudes);
-        wasm_v128_store(results, distances);
+        v128_t distances_f64x2 = nk_haversine_f64x2_v128relaxed_(first_latitudes_f64x2, first_longitudes_f64x2,
+                                                                 second_latitudes_f64x2, second_longitudes_f64x2);
+        wasm_v128_store(results, distances_f64x2);
 
         a_lats += 2, a_lons += 2, b_lats += 2, b_lons += 2, results += 2, n -= 2;
     }
@@ -113,54 +117,58 @@ NK_PUBLIC void nk_haversine_f64_v128relaxed(        //
         nk_partial_load_b64x2_serial_(a_lons, &a_lon_vec, n);
         nk_partial_load_b64x2_serial_(b_lats, &b_lat_vec, n);
         nk_partial_load_b64x2_serial_(b_lons, &b_lon_vec, n);
-        v128_t distances = nk_haversine_f64x2_v128relaxed_(a_lat_vec.v128, a_lon_vec.v128, b_lat_vec.v128,
-                                                           b_lon_vec.v128);
-        result_vec.v128 = distances;
+        v128_t distances_f64x2 = nk_haversine_f64x2_v128relaxed_(a_lat_vec.v128, a_lon_vec.v128, b_lat_vec.v128,
+                                                                 b_lon_vec.v128);
+        result_vec.v128 = distances_f64x2;
         nk_partial_store_b64x2_serial_(&result_vec, results, n);
     }
 }
 
-NK_INTERNAL v128_t nk_haversine_f32x4_v128relaxed_(  //
-    v128_t first_latitudes, v128_t first_longitudes, //
-    v128_t second_latitudes, v128_t second_longitudes) {
+NK_INTERNAL v128_t nk_haversine_f32x4_v128relaxed_(              //
+    v128_t first_latitudes_f32x4, v128_t first_longitudes_f32x4, //
+    v128_t second_latitudes_f32x4, v128_t second_longitudes_f32x4) {
 
-    v128_t const earth_radius = wasm_f32x4_splat((float)NK_EARTH_MEDIATORIAL_RADIUS);
-    v128_t const half = wasm_f32x4_splat(0.5f);
-    v128_t const one = wasm_f32x4_splat(1.0f);
-    v128_t const two = wasm_f32x4_splat(2.0f);
+    v128_t const earth_radius_f32x4 = wasm_f32x4_splat((float)NK_EARTH_MEDIATORIAL_RADIUS);
+    v128_t const half_f32x4 = wasm_f32x4_splat(0.5f);
+    v128_t const one_f32x4 = wasm_f32x4_splat(1.0f);
+    v128_t const two_f32x4 = wasm_f32x4_splat(2.0f);
 
-    v128_t latitude_delta = wasm_f32x4_sub(second_latitudes, first_latitudes);
-    v128_t longitude_delta = wasm_f32x4_sub(second_longitudes, first_longitudes);
+    v128_t latitude_delta_f32x4 = wasm_f32x4_sub(second_latitudes_f32x4, first_latitudes_f32x4);
+    v128_t longitude_delta_f32x4 = wasm_f32x4_sub(second_longitudes_f32x4, first_longitudes_f32x4);
 
     // Haversine terms: sin^2(delta/2)
-    v128_t latitude_delta_half = wasm_f32x4_mul(latitude_delta, half);
-    v128_t longitude_delta_half = wasm_f32x4_mul(longitude_delta, half);
-    v128_t sin_latitude_delta_half = nk_f32x4_sin_v128relaxed_(latitude_delta_half);
-    v128_t sin_longitude_delta_half = nk_f32x4_sin_v128relaxed_(longitude_delta_half);
-    v128_t sin_squared_latitude_delta_half = wasm_f32x4_mul(sin_latitude_delta_half, sin_latitude_delta_half);
-    v128_t sin_squared_longitude_delta_half = wasm_f32x4_mul(sin_longitude_delta_half, sin_longitude_delta_half);
+    v128_t latitude_delta_half_f32x4 = wasm_f32x4_mul(latitude_delta_f32x4, half_f32x4);
+    v128_t longitude_delta_half_f32x4 = wasm_f32x4_mul(longitude_delta_f32x4, half_f32x4);
+    v128_t sin_latitude_delta_half_f32x4 = nk_f32x4_sin_v128relaxed_(latitude_delta_half_f32x4);
+    v128_t sin_longitude_delta_half_f32x4 = nk_f32x4_sin_v128relaxed_(longitude_delta_half_f32x4);
+    v128_t sin_squared_latitude_delta_half_f32x4 = wasm_f32x4_mul(sin_latitude_delta_half_f32x4,
+                                                                  sin_latitude_delta_half_f32x4);
+    v128_t sin_squared_longitude_delta_half_f32x4 = wasm_f32x4_mul(sin_longitude_delta_half_f32x4,
+                                                                   sin_longitude_delta_half_f32x4);
 
     // Latitude cosine product
-    v128_t cos_first_latitude = nk_f32x4_cos_v128relaxed_(first_latitudes);
-    v128_t cos_second_latitude = nk_f32x4_cos_v128relaxed_(second_latitudes);
-    v128_t cos_latitude_product = wasm_f32x4_mul(cos_first_latitude, cos_second_latitude);
+    v128_t cos_first_latitude_f32x4 = nk_f32x4_cos_v128relaxed_(first_latitudes_f32x4);
+    v128_t cos_second_latitude_f32x4 = nk_f32x4_cos_v128relaxed_(second_latitudes_f32x4);
+    v128_t cos_latitude_product_f32x4 = wasm_f32x4_mul(cos_first_latitude_f32x4, cos_second_latitude_f32x4);
 
     // a = sin^2(dlat/2) + cos(lat1) * cos(lat2) * sin^2(dlon/2)
-    v128_t haversine_term = wasm_f32x4_add(sin_squared_latitude_delta_half,
-                                           wasm_f32x4_mul(cos_latitude_product, sin_squared_longitude_delta_half));
+    v128_t haversine_term_f32x4 = wasm_f32x4_add(
+        sin_squared_latitude_delta_half_f32x4,
+        wasm_f32x4_mul(cos_latitude_product_f32x4, sin_squared_longitude_delta_half_f32x4));
 
     // Clamp to [0, 1] to avoid NaN from sqrt of negative numbers (due to floating point errors)
-    // relaxed_min/max: 1 instruction (minps/maxps) vs 6-9 (with NaN/signed-zero fixup) on x86.
-    // Safe because haversine_term is a product of finite sin/cos values — NaN is impossible.
-    v128_t zero = wasm_f32x4_splat(0.0f);
-    haversine_term = wasm_f32x4_relaxed_max(zero, wasm_f32x4_relaxed_min(one, haversine_term));
+    // relaxed_min/max: 1 instruction (minps/maxps) vs 6-9 (with NaN/signed-zero_f32x4 fixup) on x86.
+    // Safe because haversine_term_f32x4 is a product of finite sin/cos values — NaN is impossible.
+    v128_t zero_f32x4 = wasm_f32x4_splat(0.0f);
+    haversine_term_f32x4 = wasm_f32x4_relaxed_max(zero_f32x4, wasm_f32x4_relaxed_min(one_f32x4, haversine_term_f32x4));
 
     // Central angle: c = 2 * atan2(sqrt(a), sqrt(1-a))
-    v128_t sqrt_haversine = wasm_f32x4_sqrt(haversine_term);
-    v128_t sqrt_complement = wasm_f32x4_sqrt(wasm_f32x4_sub(one, haversine_term));
-    v128_t central_angle = wasm_f32x4_mul(two, nk_f32x4_atan2_v128relaxed_(sqrt_haversine, sqrt_complement));
+    v128_t sqrt_haversine_f32x4 = wasm_f32x4_sqrt(haversine_term_f32x4);
+    v128_t sqrt_complement_f32x4 = wasm_f32x4_sqrt(wasm_f32x4_sub(one_f32x4, haversine_term_f32x4));
+    v128_t central_angle_f32x4 = wasm_f32x4_mul(
+        two_f32x4, nk_f32x4_atan2_v128relaxed_(sqrt_haversine_f32x4, sqrt_complement_f32x4));
 
-    return wasm_f32x4_mul(earth_radius, central_angle);
+    return wasm_f32x4_mul(earth_radius_f32x4, central_angle_f32x4);
 }
 
 NK_PUBLIC void nk_haversine_f32_v128relaxed(        //
@@ -169,14 +177,14 @@ NK_PUBLIC void nk_haversine_f32_v128relaxed(        //
     nk_size_t n, nk_f32_t *results) {
 
     while (n >= 4) {
-        v128_t first_latitudes = wasm_v128_load(a_lats);
-        v128_t first_longitudes = wasm_v128_load(a_lons);
-        v128_t second_latitudes = wasm_v128_load(b_lats);
-        v128_t second_longitudes = wasm_v128_load(b_lons);
+        v128_t first_latitudes_f32x4 = wasm_v128_load(a_lats);
+        v128_t first_longitudes_f32x4 = wasm_v128_load(a_lons);
+        v128_t second_latitudes_f32x4 = wasm_v128_load(b_lats);
+        v128_t second_longitudes_f32x4 = wasm_v128_load(b_lons);
 
-        v128_t distances = nk_haversine_f32x4_v128relaxed_(first_latitudes, first_longitudes, second_latitudes,
-                                                           second_longitudes);
-        wasm_v128_store(results, distances);
+        v128_t distances_f32x4 = nk_haversine_f32x4_v128relaxed_(first_latitudes_f32x4, first_longitudes_f32x4,
+                                                                 second_latitudes_f32x4, second_longitudes_f32x4);
+        wasm_v128_store(results, distances_f32x4);
 
         a_lats += 4, a_lons += 4, b_lats += 4, b_lons += 4, results += 4, n -= 4;
     }
@@ -188,9 +196,9 @@ NK_PUBLIC void nk_haversine_f32_v128relaxed(        //
         nk_partial_load_b32x4_serial_(a_lons, &a_lon_vec, n);
         nk_partial_load_b32x4_serial_(b_lats, &b_lat_vec, n);
         nk_partial_load_b32x4_serial_(b_lons, &b_lon_vec, n);
-        v128_t distances = nk_haversine_f32x4_v128relaxed_(a_lat_vec.v128, a_lon_vec.v128, b_lat_vec.v128,
-                                                           b_lon_vec.v128);
-        result_vec.v128 = distances;
+        v128_t distances_f32x4 = nk_haversine_f32x4_v128relaxed_(a_lat_vec.v128, a_lon_vec.v128, b_lat_vec.v128,
+                                                                 b_lon_vec.v128);
+        result_vec.v128 = distances_f32x4;
         nk_partial_store_b32x4_serial_(&result_vec, results, n);
     }
 }
@@ -199,174 +207,189 @@ NK_PUBLIC void nk_haversine_f32_v128relaxed(        //
  *  @brief  WASM Relaxed SIMD helper for Vincenty's geodesic distance on 2 f64 point pairs.
  *  @note   This is a true SIMD implementation using masked convergence tracking via blending.
  */
-NK_INTERNAL v128_t nk_vincenty_f64x2_v128relaxed_(   //
-    v128_t first_latitudes, v128_t first_longitudes, //
-    v128_t second_latitudes, v128_t second_longitudes) {
-
-    v128_t const equatorial_radius = wasm_f64x2_splat(NK_EARTH_ELLIPSOID_EQUATORIAL_RADIUS);
-    v128_t const polar_radius = wasm_f64x2_splat(NK_EARTH_ELLIPSOID_POLAR_RADIUS);
-    v128_t const flattening = wasm_f64x2_splat(1.0 / NK_EARTH_ELLIPSOID_INVERSE_FLATTENING);
-    v128_t const convergence_threshold = wasm_f64x2_splat(NK_VINCENTY_CONVERGENCE_THRESHOLD_F64);
-    v128_t const one = wasm_f64x2_splat(1.0);
-    v128_t const two = wasm_f64x2_splat(2.0);
-    v128_t const three = wasm_f64x2_splat(3.0);
-    v128_t const four = wasm_f64x2_splat(4.0);
-    v128_t const six = wasm_f64x2_splat(6.0);
-    v128_t const sixteen = wasm_f64x2_splat(16.0);
-    v128_t const epsilon = wasm_f64x2_splat(1e-15);
+NK_INTERNAL v128_t nk_vincenty_f64x2_v128relaxed_(               //
+    v128_t first_latitudes_f64x2, v128_t first_longitudes_f64x2, //
+    v128_t second_latitudes_f64x2, v128_t second_longitudes_f64x2) {
+
+    v128_t const equatorial_radius_f64x2 = wasm_f64x2_splat(NK_EARTH_ELLIPSOID_EQUATORIAL_RADIUS);
+    v128_t const polar_radius_f64x2 = wasm_f64x2_splat(NK_EARTH_ELLIPSOID_POLAR_RADIUS);
+    v128_t const flattening_f64x2 = wasm_f64x2_splat(1.0 / NK_EARTH_ELLIPSOID_INVERSE_FLATTENING);
+    v128_t const convergence_threshold_f64x2 = wasm_f64x2_splat(NK_VINCENTY_CONVERGENCE_THRESHOLD_F64);
+    v128_t const one_f64x2 = wasm_f64x2_splat(1.0);
+    v128_t const two_f64x2 = wasm_f64x2_splat(2.0);
+    v128_t const three_f64x2 = wasm_f64x2_splat(3.0);
+    v128_t const four_f64x2 = wasm_f64x2_splat(4.0);
+    v128_t const six_f64x2 = wasm_f64x2_splat(6.0);
+    v128_t const sixteen_f64x2 = wasm_f64x2_splat(16.0);
+    v128_t const epsilon_f64x2 = wasm_f64x2_splat(1e-15);
 
     // Longitude difference
-    v128_t longitude_difference = wasm_f64x2_sub(second_longitudes, first_longitudes);
+    v128_t longitude_difference_f64x2 = wasm_f64x2_sub(second_longitudes_f64x2, first_longitudes_f64x2);
 
     // Reduced latitudes: tan(U) = (1-f) * tan(lat)
-    v128_t one_minus_f = wasm_f64x2_sub(one, flattening);
-    v128_t tan_first = wasm_f64x2_div(nk_f64x2_sin_v128relaxed_(first_latitudes),
-                                      nk_f64x2_cos_v128relaxed_(first_latitudes));
-    v128_t tan_second = wasm_f64x2_div(nk_f64x2_sin_v128relaxed_(second_latitudes),
-                                       nk_f64x2_cos_v128relaxed_(second_latitudes));
-    v128_t tan_reduced_first = wasm_f64x2_mul(one_minus_f, tan_first);
-    v128_t tan_reduced_second = wasm_f64x2_mul(one_minus_f, tan_second);
+    v128_t one_minus_f_f64x2 = wasm_f64x2_sub(one_f64x2, flattening_f64x2);
+    v128_t tan_first_f64x2 = wasm_f64x2_div(nk_f64x2_sin_v128relaxed_(first_latitudes_f64x2),
+                                            nk_f64x2_cos_v128relaxed_(first_latitudes_f64x2));
+    v128_t tan_second_f64x2 = wasm_f64x2_div(nk_f64x2_sin_v128relaxed_(second_latitudes_f64x2),
+                                             nk_f64x2_cos_v128relaxed_(second_latitudes_f64x2));
+    v128_t tan_reduced_first_f64x2 = wasm_f64x2_mul(one_minus_f_f64x2, tan_first_f64x2);
+    v128_t tan_reduced_second_f64x2 = wasm_f64x2_mul(one_minus_f_f64x2, tan_second_f64x2);
 
     // cos(U) = 1/sqrt(1 + tan^2(U)), sin(U) = tan(U) * cos(U)
-    v128_t cos_reduced_first = wasm_f64x2_div(
-        one, wasm_f64x2_sqrt(wasm_f64x2_relaxed_madd(tan_reduced_first, tan_reduced_first, one)));
-    v128_t sin_reduced_first = wasm_f64x2_mul(tan_reduced_first, cos_reduced_first);
-    v128_t cos_reduced_second = wasm_f64x2_div(
-        one, wasm_f64x2_sqrt(wasm_f64x2_relaxed_madd(tan_reduced_second, tan_reduced_second, one)));
-    v128_t sin_reduced_second = wasm_f64x2_mul(tan_reduced_second, cos_reduced_second);
-
-    // Initialize lambda and tracking variables
-    v128_t lambda = longitude_difference;
-    v128_t sin_angular_distance, cos_angular_distance, angular_distance;
-    v128_t sin_azimuth, cos_squared_azimuth, cos_double_angular_midpoint;
+    v128_t cos_reduced_first_f64x2 = wasm_f64x2_div(
+        one_f64x2,
+        wasm_f64x2_sqrt(wasm_f64x2_relaxed_madd(tan_reduced_first_f64x2, tan_reduced_first_f64x2, one_f64x2)));
+    v128_t sin_reduced_first_f64x2 = wasm_f64x2_mul(tan_reduced_first_f64x2, cos_reduced_first_f64x2);
+    v128_t cos_reduced_second_f64x2 = wasm_f64x2_div(
+        one_f64x2,
+        wasm_f64x2_sqrt(wasm_f64x2_relaxed_madd(tan_reduced_second_f64x2, tan_reduced_second_f64x2, one_f64x2)));
+    v128_t sin_reduced_second_f64x2 = wasm_f64x2_mul(tan_reduced_second_f64x2, cos_reduced_second_f64x2);
+
+    // Initialize lambda_f64x2 and tracking variables
+    v128_t lambda_f64x2 = longitude_difference_f64x2;
+    v128_t sin_angular_distance_f64x2, cos_angular_distance_f64x2, angular_distance_f64x2;
+    v128_t sin_azimuth_f64x2, cos_squared_azimuth_f64x2, cos_double_angular_midpoint_f64x2;
 
     // Track convergence and coincident points using masks
-    v128_t converged_mask = wasm_i64x2_splat(0);
-    v128_t coincident_mask = wasm_i64x2_splat(0);
+    v128_t converged_mask_i64x2 = wasm_i64x2_splat(0);
+    v128_t coincident_mask_i64x2 = wasm_i64x2_splat(0);
 
     for (nk_u32_t iteration = 0; iteration < NK_VINCENTY_MAX_ITERATIONS; ++iteration) {
         // Check if all lanes converged
-        if (wasm_i8x16_all_true(converged_mask)) break;
+        if (wasm_i8x16_all_true(converged_mask_i64x2)) break;
 
-        v128_t sin_lambda = nk_f64x2_sin_v128relaxed_(lambda);
-        v128_t cos_lambda = nk_f64x2_cos_v128relaxed_(lambda);
+        v128_t sin_lambda_f64x2 = nk_f64x2_sin_v128relaxed_(lambda_f64x2);
+        v128_t cos_lambda_f64x2 = nk_f64x2_cos_v128relaxed_(lambda_f64x2);
 
-        // sin^2(angular_distance) = (cos(U2) * sin(l))^2 + (cos(U1) * sin(U2) - sin(U1) * cos(U2) * cos(l))^2
-        v128_t cross_term = wasm_f64x2_mul(cos_reduced_second, sin_lambda);
-        v128_t mixed_term = wasm_f64x2_sub(
-            wasm_f64x2_mul(cos_reduced_first, sin_reduced_second),
-            wasm_f64x2_mul(wasm_f64x2_mul(sin_reduced_first, cos_reduced_second), cos_lambda));
-        v128_t sin_angular_dist_sq = wasm_f64x2_relaxed_madd(cross_term, cross_term,
-                                                             wasm_f64x2_mul(mixed_term, mixed_term));
-        sin_angular_distance = wasm_f64x2_sqrt(sin_angular_dist_sq);
+        // sin^2(angular_distance_f64x2) = (cos(U2) * sin(l))^2 + (cos(U1) * sin(U2) - sin(U1) * cos(U2) * cos(l))^2
+        v128_t cross_term_f64x2 = wasm_f64x2_mul(cos_reduced_second_f64x2, sin_lambda_f64x2);
+        v128_t mixed_term_f64x2 = wasm_f64x2_sub(
+            wasm_f64x2_mul(cos_reduced_first_f64x2, sin_reduced_second_f64x2),
+            wasm_f64x2_mul(wasm_f64x2_mul(sin_reduced_first_f64x2, cos_reduced_second_f64x2), cos_lambda_f64x2));
+        v128_t sin_angular_dist_sq_f64x2 = wasm_f64x2_relaxed_madd(cross_term_f64x2, cross_term_f64x2,
+                                                                   wasm_f64x2_mul(mixed_term_f64x2, mixed_term_f64x2));
+        sin_angular_distance_f64x2 = wasm_f64x2_sqrt(sin_angular_dist_sq_f64x2);
 
-        // Check for coincident points (sin_angular_distance ~ 0)
-        coincident_mask = wasm_f64x2_lt(sin_angular_distance, epsilon);
+        // Check for coincident points (sin_angular_distance_f64x2 ~ 0)
+        coincident_mask_i64x2 = wasm_f64x2_lt(sin_angular_distance_f64x2, epsilon_f64x2);
 
-        // cos(angular_distance) = sin(U1) * sin(U2) + cos(U1) * cos(U2) * cos(l)
-        cos_angular_distance = wasm_f64x2_relaxed_madd(wasm_f64x2_mul(cos_reduced_first, cos_reduced_second),
-                                                       cos_lambda,
-                                                       wasm_f64x2_mul(sin_reduced_first, sin_reduced_second));
+        // cos(angular_distance_f64x2) = sin(U1) * sin(U2) + cos(U1) * cos(U2) * cos(l)
+        cos_angular_distance_f64x2 = wasm_f64x2_relaxed_madd(
+            wasm_f64x2_mul(cos_reduced_first_f64x2, cos_reduced_second_f64x2), cos_lambda_f64x2,
+            wasm_f64x2_mul(sin_reduced_first_f64x2, sin_reduced_second_f64x2));
 
-        // angular_distance = atan2(sin, cos)
-        angular_distance = nk_f64x2_atan2_v128relaxed_(sin_angular_distance, cos_angular_distance);
+        // angular_distance_f64x2 = atan2(sin, cos)
+        angular_distance_f64x2 = nk_f64x2_atan2_v128relaxed_(sin_angular_distance_f64x2, cos_angular_distance_f64x2);
 
-        // sin(azimuth) = cos(U1) * cos(U2) * sin(l) / sin(angular_distance)
+        // sin(azimuth) = cos(U1) * cos(U2) * sin(l) / sin(angular_distance_f64x2)
         // Avoid division by zero by using blending
         // relaxed_laneselect: 1 instruction (vblendvpd) vs 3 (vpand+vpandn+vpor) on x86.
         // Safe because mask is from comparison (all-ones or all-zeros per lane).
-        v128_t safe_sin_angular = wasm_i64x2_relaxed_laneselect(one, sin_angular_distance, coincident_mask);
-        sin_azimuth = wasm_f64x2_div(wasm_f64x2_mul(wasm_f64x2_mul(cos_reduced_first, cos_reduced_second), sin_lambda),
-                                     safe_sin_angular);
-        cos_squared_azimuth = wasm_f64x2_relaxed_nmadd(sin_azimuth, sin_azimuth, one);
+        v128_t safe_sin_angular_i64x2 = wasm_i64x2_relaxed_laneselect(one_f64x2, sin_angular_distance_f64x2,
+                                                                      coincident_mask_i64x2);
+        sin_azimuth_f64x2 = wasm_f64x2_div(
+            wasm_f64x2_mul(wasm_f64x2_mul(cos_reduced_first_f64x2, cos_reduced_second_f64x2), sin_lambda_f64x2),
+            safe_sin_angular_i64x2);
+        cos_squared_azimuth_f64x2 = wasm_f64x2_relaxed_nmadd(sin_azimuth_f64x2, sin_azimuth_f64x2, one_f64x2);
 
         // Handle equatorial case: cos^2(a) ~ 0
-        v128_t equatorial_mask = wasm_f64x2_lt(cos_squared_azimuth, epsilon);
-        v128_t safe_cos_sq_azimuth = wasm_i64x2_relaxed_laneselect(one, cos_squared_azimuth, equatorial_mask);
+        v128_t equatorial_mask_f64x2 = wasm_f64x2_lt(cos_squared_azimuth_f64x2, epsilon_f64x2);
+        v128_t safe_cos_sq_azimuth_i64x2 = wasm_i64x2_relaxed_laneselect(one_f64x2, cos_squared_azimuth_f64x2,
+                                                                         equatorial_mask_f64x2);
 
         // cos(2sm) = cos(s) - 2 * sin(U1) * sin(U2) / cos^2(a)
-        v128_t sin_product = wasm_f64x2_mul(sin_reduced_first, sin_reduced_second);
-        cos_double_angular_midpoint = wasm_f64x2_sub(
-            cos_angular_distance, wasm_f64x2_div(wasm_f64x2_mul(two, sin_product), safe_cos_sq_azimuth));
-        cos_double_angular_midpoint = wasm_i64x2_relaxed_laneselect(wasm_f64x2_splat(0.0), cos_double_angular_midpoint,
-                                                                    equatorial_mask);
+        v128_t sin_product_f64x2 = wasm_f64x2_mul(sin_reduced_first_f64x2, sin_reduced_second_f64x2);
+        cos_double_angular_midpoint_f64x2 = wasm_f64x2_sub(
+            cos_angular_distance_f64x2,
+            wasm_f64x2_div(wasm_f64x2_mul(two_f64x2, sin_product_f64x2), safe_cos_sq_azimuth_i64x2));
+        cos_double_angular_midpoint_f64x2 = wasm_i64x2_relaxed_laneselect(
+            wasm_f64x2_splat(0.0), cos_double_angular_midpoint_f64x2, equatorial_mask_f64x2);
 
         // C = f/16 * cos^2(a) * (4 + f*(4 - 3*cos^2(a)))
-        v128_t correction_factor = wasm_f64x2_mul(
-            wasm_f64x2_div(flattening, sixteen),
+        v128_t correction_factor_f64x2 = wasm_f64x2_mul(
+            wasm_f64x2_div(flattening_f64x2, sixteen_f64x2),
             wasm_f64x2_mul(
-                cos_squared_azimuth,
-                wasm_f64x2_relaxed_madd(flattening, wasm_f64x2_relaxed_nmadd(three, cos_squared_azimuth, four), four)));
+                cos_squared_azimuth_f64x2,
+                wasm_f64x2_relaxed_madd(flattening_f64x2,
+                                        wasm_f64x2_relaxed_nmadd(three_f64x2, cos_squared_azimuth_f64x2, four_f64x2),
+                                        four_f64x2)));
 
         // l' = L + (1-C) * f * sin(a) * (s + C * sin(s) * (cos(2sm) + C * cos(s) * (-1 + 2 * cos^2(2sm))))
-        v128_t cos_2sm_sq = wasm_f64x2_mul(cos_double_angular_midpoint, cos_double_angular_midpoint);
-        // innermost = -1 + 2 * cos^2(2sm)
-        v128_t innermost = wasm_f64x2_relaxed_madd(two, cos_2sm_sq, wasm_f64x2_splat(-1.0));
-        // middle = cos(2sm) + C * cos(s) * innermost
-        v128_t middle = wasm_f64x2_relaxed_madd(wasm_f64x2_mul(correction_factor, cos_angular_distance), innermost,
-                                                cos_double_angular_midpoint);
-        // inner = C * sin(s) * middle
-        v128_t inner = wasm_f64x2_mul(wasm_f64x2_mul(correction_factor, sin_angular_distance), middle);
-
-        // l' = L + (1-C) * f * sin_a * (s + inner)
-        v128_t lambda_new = wasm_f64x2_relaxed_madd(
-            wasm_f64x2_mul(wasm_f64x2_mul(wasm_f64x2_sub(one, correction_factor), flattening), sin_azimuth),
-            wasm_f64x2_add(angular_distance, inner), longitude_difference);
+        v128_t cos_2sm_sq_f64x2 = wasm_f64x2_mul(cos_double_angular_midpoint_f64x2, cos_double_angular_midpoint_f64x2);
+        // innermost_f64x2 = -1 + 2 * cos^2(2sm)
+        v128_t innermost_f64x2 = wasm_f64x2_relaxed_madd(two_f64x2, cos_2sm_sq_f64x2, wasm_f64x2_splat(-1.0));
+        // middle_f64x2 = cos(2sm) + C * cos(s) * innermost_f64x2
+        v128_t middle_f64x2 = wasm_f64x2_relaxed_madd(
+            wasm_f64x2_mul(correction_factor_f64x2, cos_angular_distance_f64x2), innermost_f64x2,
+            cos_double_angular_midpoint_f64x2);
+        // inner_f64x2 = C * sin(s) * middle_f64x2
+        v128_t inner_f64x2 = wasm_f64x2_mul(wasm_f64x2_mul(correction_factor_f64x2, sin_angular_distance_f64x2),
+                                            middle_f64x2);
+
+        // l' = L + (1-C) * f * sin_a * (s + inner_f64x2)
+        v128_t lambda_new_f64x2 = wasm_f64x2_relaxed_madd(
+            wasm_f64x2_mul(wasm_f64x2_mul(wasm_f64x2_sub(one_f64x2, correction_factor_f64x2), flattening_f64x2),
+                           sin_azimuth_f64x2),
+            wasm_f64x2_add(angular_distance_f64x2, inner_f64x2), longitude_difference_f64x2);
 
         // Check convergence: |l - l'| < threshold
-        v128_t lambda_diff = wasm_f64x2_sub(lambda_new, lambda);
-        v128_t lambda_diff_abs = wasm_f64x2_abs(lambda_diff);
-        v128_t newly_converged = wasm_f64x2_lt(lambda_diff_abs, convergence_threshold);
-        converged_mask = wasm_v128_or(converged_mask, newly_converged);
+        v128_t lambda_diff_f64x2 = wasm_f64x2_sub(lambda_new_f64x2, lambda_f64x2);
+        v128_t lambda_diff_abs_f64x2 = wasm_f64x2_abs(lambda_diff_f64x2);
+        v128_t newly_converged_f64x2 = wasm_f64x2_lt(lambda_diff_abs_f64x2, convergence_threshold_f64x2);
+        converged_mask_i64x2 = wasm_v128_or(converged_mask_i64x2, newly_converged_f64x2);
 
-        // Only update lambda for non-converged lanes
+        // Only update lambda_f64x2 for non-converged lanes
         // relaxed_laneselect: 1 instruction (vblendvpd) vs 3 (vpand+vpandn+vpor) on x86.
         // Safe because mask is from comparison (all-ones or all-zeros per lane).
-        lambda = wasm_i64x2_relaxed_laneselect(lambda, lambda_new, converged_mask);
+        lambda_f64x2 = wasm_i64x2_relaxed_laneselect(lambda_f64x2, lambda_new_f64x2, converged_mask_i64x2);
     }
 
     // Final distance calculation
     // u^2 = cos^2(a) * (a^2 - b^2) / b^2
-    v128_t a_sq = wasm_f64x2_mul(equatorial_radius, equatorial_radius);
-    v128_t b_sq = wasm_f64x2_mul(polar_radius, polar_radius);
-    v128_t u_squared = wasm_f64x2_div(wasm_f64x2_mul(cos_squared_azimuth, wasm_f64x2_sub(a_sq, b_sq)), b_sq);
+    v128_t a_sq_f64x2 = wasm_f64x2_mul(equatorial_radius_f64x2, equatorial_radius_f64x2);
+    v128_t b_sq_f64x2 = wasm_f64x2_mul(polar_radius_f64x2, polar_radius_f64x2);
+    v128_t u_squared_f64x2 = wasm_f64x2_div(
+        wasm_f64x2_mul(cos_squared_azimuth_f64x2, wasm_f64x2_sub(a_sq_f64x2, b_sq_f64x2)), b_sq_f64x2);
 
     // A = 1 + u^2/16384 * (4096 + u^2*(-768 + u^2*(320 - 175*u^2)))
-    v128_t series_a = wasm_f64x2_relaxed_madd(u_squared, wasm_f64x2_splat(-175.0), wasm_f64x2_splat(320.0));
-    series_a = wasm_f64x2_relaxed_madd(u_squared, series_a, wasm_f64x2_splat(-768.0));
-    series_a = wasm_f64x2_relaxed_madd(u_squared, series_a, wasm_f64x2_splat(4096.0));
-    series_a = wasm_f64x2_relaxed_madd(wasm_f64x2_div(u_squared, wasm_f64x2_splat(16384.0)), series_a, one);
+    v128_t series_a_f64x2 = wasm_f64x2_relaxed_madd(u_squared_f64x2, wasm_f64x2_splat(-175.0), wasm_f64x2_splat(320.0));
+    series_a_f64x2 = wasm_f64x2_relaxed_madd(u_squared_f64x2, series_a_f64x2, wasm_f64x2_splat(-768.0));
+    series_a_f64x2 = wasm_f64x2_relaxed_madd(u_squared_f64x2, series_a_f64x2, wasm_f64x2_splat(4096.0));
+    series_a_f64x2 = wasm_f64x2_relaxed_madd(wasm_f64x2_div(u_squared_f64x2, wasm_f64x2_splat(16384.0)), series_a_f64x2,
+                                             one_f64x2);
 
     // B = u^2/1024 * (256 + u^2*(-128 + u^2*(74 - 47*u^2)))
-    v128_t series_b = wasm_f64x2_relaxed_madd(u_squared, wasm_f64x2_splat(-47.0), wasm_f64x2_splat(74.0));
-    series_b = wasm_f64x2_relaxed_madd(u_squared, series_b, wasm_f64x2_splat(-128.0));
-    series_b = wasm_f64x2_relaxed_madd(u_squared, series_b, wasm_f64x2_splat(256.0));
-    series_b = wasm_f64x2_mul(wasm_f64x2_div(u_squared, wasm_f64x2_splat(1024.0)), series_b);
+    v128_t series_b_f64x2 = wasm_f64x2_relaxed_madd(u_squared_f64x2, wasm_f64x2_splat(-47.0), wasm_f64x2_splat(74.0));
+    series_b_f64x2 = wasm_f64x2_relaxed_madd(u_squared_f64x2, series_b_f64x2, wasm_f64x2_splat(-128.0));
+    series_b_f64x2 = wasm_f64x2_relaxed_madd(u_squared_f64x2, series_b_f64x2, wasm_f64x2_splat(256.0));
+    series_b_f64x2 = wasm_f64x2_mul(wasm_f64x2_div(u_squared_f64x2, wasm_f64x2_splat(1024.0)), series_b_f64x2);
 
     // Delta-sigma calculation
-    v128_t cos_2sm_sq = wasm_f64x2_mul(cos_double_angular_midpoint, cos_double_angular_midpoint);
-    v128_t sin_sq = wasm_f64x2_mul(sin_angular_distance, sin_angular_distance);
-    v128_t term1 = wasm_f64x2_relaxed_madd(two, cos_2sm_sq, wasm_f64x2_splat(-1.0));
-    term1 = wasm_f64x2_mul(cos_angular_distance, term1);
-    v128_t term2 = wasm_f64x2_relaxed_madd(four, sin_sq, wasm_f64x2_splat(-3.0));
-    v128_t term3 = wasm_f64x2_relaxed_madd(four, cos_2sm_sq, wasm_f64x2_splat(-3.0));
-    term2 = wasm_f64x2_mul(wasm_f64x2_mul(wasm_f64x2_div(series_b, six), cos_double_angular_midpoint),
-                           wasm_f64x2_mul(term2, term3));
-    v128_t delta_sigma = wasm_f64x2_mul(
-        series_b, wasm_f64x2_mul(sin_angular_distance, wasm_f64x2_add(cos_double_angular_midpoint,
-                                                                      wasm_f64x2_mul(wasm_f64x2_div(series_b, four),
-                                                                                     wasm_f64x2_sub(term1, term2)))));
+    v128_t cos_2sm_sq_f64x2 = wasm_f64x2_mul(cos_double_angular_midpoint_f64x2, cos_double_angular_midpoint_f64x2);
+    v128_t sin_sq_f64x2 = wasm_f64x2_mul(sin_angular_distance_f64x2, sin_angular_distance_f64x2);
+    v128_t term1_f64x2 = wasm_f64x2_relaxed_madd(two_f64x2, cos_2sm_sq_f64x2, wasm_f64x2_splat(-1.0));
+    term1_f64x2 = wasm_f64x2_mul(cos_angular_distance_f64x2, term1_f64x2);
+    v128_t term2_f64x2 = wasm_f64x2_relaxed_madd(four_f64x2, sin_sq_f64x2, wasm_f64x2_splat(-3.0));
+    v128_t term3_f64x2 = wasm_f64x2_relaxed_madd(four_f64x2, cos_2sm_sq_f64x2, wasm_f64x2_splat(-3.0));
+    term2_f64x2 = wasm_f64x2_mul(
+        wasm_f64x2_mul(wasm_f64x2_div(series_b_f64x2, six_f64x2), cos_double_angular_midpoint_f64x2),
+        wasm_f64x2_mul(term2_f64x2, term3_f64x2));
+    v128_t delta_sigma_f64x2 = wasm_f64x2_mul(
+        series_b_f64x2, wasm_f64x2_mul(sin_angular_distance_f64x2,
+                                       wasm_f64x2_add(cos_double_angular_midpoint_f64x2,
+                                                      wasm_f64x2_mul(wasm_f64x2_div(series_b_f64x2, four_f64x2),
+                                                                     wasm_f64x2_sub(term1_f64x2, term2_f64x2)))));
 
     // s = b * A * (s - ds)
-    v128_t distances = wasm_f64x2_mul(wasm_f64x2_mul(polar_radius, series_a),
-                                      wasm_f64x2_sub(angular_distance, delta_sigma));
+    v128_t distances_f64x2 = wasm_f64x2_mul(wasm_f64x2_mul(polar_radius_f64x2, series_a_f64x2),
+                                            wasm_f64x2_sub(angular_distance_f64x2, delta_sigma_f64x2));
 
     // Set coincident points to zero
     // relaxed_laneselect: 1 instruction (vblendvpd) vs 3 (vpand+vpandn+vpor) on x86.
     // Safe because mask is from comparison (all-ones or all-zeros per lane).
-    distances = wasm_i64x2_relaxed_laneselect(wasm_f64x2_splat(0.0), distances, coincident_mask);
+    distances_f64x2 = wasm_i64x2_relaxed_laneselect(wasm_f64x2_splat(0.0), distances_f64x2, coincident_mask_i64x2);
 
-    return distances;
+    return distances_f64x2;
 }
 
 NK_PUBLIC void nk_vincenty_f64_v128relaxed(         //
@@ -375,14 +398,14 @@ NK_PUBLIC void nk_vincenty_f64_v128relaxed(         //
     nk_size_t n, nk_f64_t *results) {
 
     while (n >= 2) {
-        v128_t first_latitudes = wasm_v128_load(a_lats);
-        v128_t first_longitudes = wasm_v128_load(a_lons);
-        v128_t second_latitudes = wasm_v128_load(b_lats);
-        v128_t second_longitudes = wasm_v128_load(b_lons);
+        v128_t first_latitudes_f64x2 = wasm_v128_load(a_lats);
+        v128_t first_longitudes_f64x2 = wasm_v128_load(a_lons);
+        v128_t second_latitudes_f64x2 = wasm_v128_load(b_lats);
+        v128_t second_longitudes_f64x2 = wasm_v128_load(b_lons);
 
-        v128_t distances = nk_vincenty_f64x2_v128relaxed_(first_latitudes, first_longitudes, second_latitudes,
-                                                          second_longitudes);
-        wasm_v128_store(results, distances);
+        v128_t distances_f64x2 = nk_vincenty_f64x2_v128relaxed_(first_latitudes_f64x2, first_longitudes_f64x2,
+                                                                second_latitudes_f64x2, second_longitudes_f64x2);
+        wasm_v128_store(results, distances_f64x2);
 
         a_lats += 2, a_lons += 2, b_lats += 2, b_lons += 2, results += 2, n -= 2;
     }
@@ -394,9 +417,9 @@ NK_PUBLIC void nk_vincenty_f64_v128relaxed(         //
         nk_partial_load_b64x2_serial_(a_lons, &a_lon_vec, n);
         nk_partial_load_b64x2_serial_(b_lats, &b_lat_vec, n);
         nk_partial_load_b64x2_serial_(b_lons, &b_lon_vec, n);
-        v128_t distances = nk_vincenty_f64x2_v128relaxed_(a_lat_vec.v128, a_lon_vec.v128, b_lat_vec.v128,
-                                                          b_lon_vec.v128);
-        result_vec.v128 = distances;
+        v128_t distances_f64x2 = nk_vincenty_f64x2_v128relaxed_(a_lat_vec.v128, a_lon_vec.v128, b_lat_vec.v128,
+                                                                b_lon_vec.v128);
+        result_vec.v128 = distances_f64x2;
         nk_partial_store_b64x2_serial_(&result_vec, results, n);
     }
 }
@@ -405,168 +428,184 @@ NK_PUBLIC void nk_vincenty_f64_v128relaxed(         //
  *  @brief  WASM Relaxed SIMD helper for Vincenty's geodesic distance on 4 f32 point pairs.
  *  @note   This is a true SIMD implementation using masked convergence tracking via blending.
  */
-NK_INTERNAL v128_t nk_vincenty_f32x4_v128relaxed_(   //
-    v128_t first_latitudes, v128_t first_longitudes, //
-    v128_t second_latitudes, v128_t second_longitudes) {
-
-    v128_t const equatorial_radius = wasm_f32x4_splat((float)NK_EARTH_ELLIPSOID_EQUATORIAL_RADIUS);
-    v128_t const polar_radius = wasm_f32x4_splat((float)NK_EARTH_ELLIPSOID_POLAR_RADIUS);
-    v128_t const flattening = wasm_f32x4_splat(1.0f / (float)NK_EARTH_ELLIPSOID_INVERSE_FLATTENING);
-    v128_t const convergence_threshold = wasm_f32x4_splat(NK_VINCENTY_CONVERGENCE_THRESHOLD_F32);
-    v128_t const one = wasm_f32x4_splat(1.0f);
-    v128_t const two = wasm_f32x4_splat(2.0f);
-    v128_t const three = wasm_f32x4_splat(3.0f);
-    v128_t const four = wasm_f32x4_splat(4.0f);
-    v128_t const six = wasm_f32x4_splat(6.0f);
-    v128_t const sixteen = wasm_f32x4_splat(16.0f);
-    v128_t const epsilon = wasm_f32x4_splat(1e-7f);
+NK_INTERNAL v128_t nk_vincenty_f32x4_v128relaxed_(               //
+    v128_t first_latitudes_f32x4, v128_t first_longitudes_f32x4, //
+    v128_t second_latitudes_f32x4, v128_t second_longitudes_f32x4) {
+
+    v128_t const equatorial_radius_f32x4 = wasm_f32x4_splat((float)NK_EARTH_ELLIPSOID_EQUATORIAL_RADIUS);
+    v128_t const polar_radius_f32x4 = wasm_f32x4_splat((float)NK_EARTH_ELLIPSOID_POLAR_RADIUS);
+    v128_t const flattening_f32x4 = wasm_f32x4_splat(1.0f / (float)NK_EARTH_ELLIPSOID_INVERSE_FLATTENING);
+    v128_t const convergence_threshold_f32x4 = wasm_f32x4_splat(NK_VINCENTY_CONVERGENCE_THRESHOLD_F32);
+    v128_t const one_f32x4 = wasm_f32x4_splat(1.0f);
+    v128_t const two_f32x4 = wasm_f32x4_splat(2.0f);
+    v128_t const three_f32x4 = wasm_f32x4_splat(3.0f);
+    v128_t const four_f32x4 = wasm_f32x4_splat(4.0f);
+    v128_t const six_f32x4 = wasm_f32x4_splat(6.0f);
+    v128_t const sixteen_f32x4 = wasm_f32x4_splat(16.0f);
+    v128_t const epsilon_f32x4 = wasm_f32x4_splat(1e-7f);
 
     // Longitude difference
-    v128_t longitude_difference = wasm_f32x4_sub(second_longitudes, first_longitudes);
+    v128_t longitude_difference_f32x4 = wasm_f32x4_sub(second_longitudes_f32x4, first_longitudes_f32x4);
 
     // Reduced latitudes: tan(U) = (1-f) * tan(lat)
-    v128_t one_minus_f = wasm_f32x4_sub(one, flattening);
-    v128_t tan_first = wasm_f32x4_div(nk_f32x4_sin_v128relaxed_(first_latitudes),
-                                      nk_f32x4_cos_v128relaxed_(first_latitudes));
-    v128_t tan_second = wasm_f32x4_div(nk_f32x4_sin_v128relaxed_(second_latitudes),
-                                       nk_f32x4_cos_v128relaxed_(second_latitudes));
-    v128_t tan_reduced_first = wasm_f32x4_mul(one_minus_f, tan_first);
-    v128_t tan_reduced_second = wasm_f32x4_mul(one_minus_f, tan_second);
+    v128_t one_minus_f_f32x4 = wasm_f32x4_sub(one_f32x4, flattening_f32x4);
+    v128_t tan_first_f32x4 = wasm_f32x4_div(nk_f32x4_sin_v128relaxed_(first_latitudes_f32x4),
+                                            nk_f32x4_cos_v128relaxed_(first_latitudes_f32x4));
+    v128_t tan_second_f32x4 = wasm_f32x4_div(nk_f32x4_sin_v128relaxed_(second_latitudes_f32x4),
+                                             nk_f32x4_cos_v128relaxed_(second_latitudes_f32x4));
+    v128_t tan_reduced_first_f32x4 = wasm_f32x4_mul(one_minus_f_f32x4, tan_first_f32x4);
+    v128_t tan_reduced_second_f32x4 = wasm_f32x4_mul(one_minus_f_f32x4, tan_second_f32x4);
 
     // cos(U) = 1/sqrt(1 + tan^2(U)), sin(U) = tan(U) * cos(U)
-    v128_t cos_reduced_first = wasm_f32x4_div(
-        one, wasm_f32x4_sqrt(wasm_f32x4_relaxed_madd(tan_reduced_first, tan_reduced_first, one)));
-    v128_t sin_reduced_first = wasm_f32x4_mul(tan_reduced_first, cos_reduced_first);
-    v128_t cos_reduced_second = wasm_f32x4_div(
-        one, wasm_f32x4_sqrt(wasm_f32x4_relaxed_madd(tan_reduced_second, tan_reduced_second, one)));
-    v128_t sin_reduced_second = wasm_f32x4_mul(tan_reduced_second, cos_reduced_second);
-
-    // Initialize lambda and tracking variables
-    v128_t lambda = longitude_difference;
-    v128_t sin_angular_distance, cos_angular_distance, angular_distance;
-    v128_t sin_azimuth, cos_squared_azimuth, cos_double_angular_midpoint;
+    v128_t cos_reduced_first_f32x4 = wasm_f32x4_div(
+        one_f32x4,
+        wasm_f32x4_sqrt(wasm_f32x4_relaxed_madd(tan_reduced_first_f32x4, tan_reduced_first_f32x4, one_f32x4)));
+    v128_t sin_reduced_first_f32x4 = wasm_f32x4_mul(tan_reduced_first_f32x4, cos_reduced_first_f32x4);
+    v128_t cos_reduced_second_f32x4 = wasm_f32x4_div(
+        one_f32x4,
+        wasm_f32x4_sqrt(wasm_f32x4_relaxed_madd(tan_reduced_second_f32x4, tan_reduced_second_f32x4, one_f32x4)));
+    v128_t sin_reduced_second_f32x4 = wasm_f32x4_mul(tan_reduced_second_f32x4, cos_reduced_second_f32x4);
+
+    // Initialize lambda_f32x4 and tracking variables
+    v128_t lambda_f32x4 = longitude_difference_f32x4;
+    v128_t sin_angular_distance_f32x4, cos_angular_distance_f32x4, angular_distance_f32x4;
+    v128_t sin_azimuth_f32x4, cos_squared_azimuth_f32x4, cos_double_angular_midpoint_f32x4;
 
     // Track convergence and coincident points using masks
-    v128_t converged_mask = wasm_i32x4_splat(0);
-    v128_t coincident_mask = wasm_i32x4_splat(0);
+    v128_t converged_mask_i32x4 = wasm_i32x4_splat(0);
+    v128_t coincident_mask_i32x4 = wasm_i32x4_splat(0);
 
     for (nk_u32_t iteration = 0; iteration < NK_VINCENTY_MAX_ITERATIONS; ++iteration) {
         // Check if all lanes converged
-        if (wasm_i8x16_all_true(converged_mask)) break;
+        if (wasm_i8x16_all_true(converged_mask_i32x4)) break;
 
-        v128_t sin_lambda = nk_f32x4_sin_v128relaxed_(lambda);
-        v128_t cos_lambda = nk_f32x4_cos_v128relaxed_(lambda);
+        v128_t sin_lambda_f32x4 = nk_f32x4_sin_v128relaxed_(lambda_f32x4);
+        v128_t cos_lambda_f32x4 = nk_f32x4_cos_v128relaxed_(lambda_f32x4);
 
-        // sin^2(angular_distance) = (cos(U2) * sin(l))^2 + (cos(U1) * sin(U2) - sin(U1) * cos(U2) * cos(l))^2
-        v128_t cross_term = wasm_f32x4_mul(cos_reduced_second, sin_lambda);
-        v128_t mixed_term = wasm_f32x4_sub(
-            wasm_f32x4_mul(cos_reduced_first, sin_reduced_second),
-            wasm_f32x4_mul(wasm_f32x4_mul(sin_reduced_first, cos_reduced_second), cos_lambda));
-        v128_t sin_angular_dist_sq = wasm_f32x4_relaxed_madd(cross_term, cross_term,
-                                                             wasm_f32x4_mul(mixed_term, mixed_term));
-        sin_angular_distance = wasm_f32x4_sqrt(sin_angular_dist_sq);
+        // sin^2(angular_distance_f32x4) = (cos(U2) * sin(l))^2 + (cos(U1) * sin(U2) - sin(U1) * cos(U2) * cos(l))^2
+        v128_t cross_term_f32x4 = wasm_f32x4_mul(cos_reduced_second_f32x4, sin_lambda_f32x4);
+        v128_t mixed_term_f32x4 = wasm_f32x4_sub(
+            wasm_f32x4_mul(cos_reduced_first_f32x4, sin_reduced_second_f32x4),
+            wasm_f32x4_mul(wasm_f32x4_mul(sin_reduced_first_f32x4, cos_reduced_second_f32x4), cos_lambda_f32x4));
+        v128_t sin_angular_dist_sq_f32x4 = wasm_f32x4_relaxed_madd(cross_term_f32x4, cross_term_f32x4,
+                                                                   wasm_f32x4_mul(mixed_term_f32x4, mixed_term_f32x4));
+        sin_angular_distance_f32x4 = wasm_f32x4_sqrt(sin_angular_dist_sq_f32x4);
 
-        // Check for coincident points (sin_angular_distance ~ 0)
-        coincident_mask = wasm_f32x4_lt(sin_angular_distance, epsilon);
+        // Check for coincident points (sin_angular_distance_f32x4 ~ 0)
+        coincident_mask_i32x4 = wasm_f32x4_lt(sin_angular_distance_f32x4, epsilon_f32x4);
 
-        // cos(angular_distance) = sin(U1) * sin(U2) + cos(U1) * cos(U2) * cos(l)
-        cos_angular_distance = wasm_f32x4_relaxed_madd(wasm_f32x4_mul(cos_reduced_first, cos_reduced_second),
-                                                       cos_lambda,
-                                                       wasm_f32x4_mul(sin_reduced_first, sin_reduced_second));
+        // cos(angular_distance_f32x4) = sin(U1) * sin(U2) + cos(U1) * cos(U2) * cos(l)
+        cos_angular_distance_f32x4 = wasm_f32x4_relaxed_madd(
+            wasm_f32x4_mul(cos_reduced_first_f32x4, cos_reduced_second_f32x4), cos_lambda_f32x4,
+            wasm_f32x4_mul(sin_reduced_first_f32x4, sin_reduced_second_f32x4));
 
-        // angular_distance = atan2(sin, cos)
-        angular_distance = nk_f32x4_atan2_v128relaxed_(sin_angular_distance, cos_angular_distance);
+        // angular_distance_f32x4 = atan2(sin, cos)
+        angular_distance_f32x4 = nk_f32x4_atan2_v128relaxed_(sin_angular_distance_f32x4, cos_angular_distance_f32x4);
 
-        // sin(azimuth) = cos(U1) * cos(U2) * sin(l) / sin(angular_distance)
+        // sin(azimuth) = cos(U1) * cos(U2) * sin(l) / sin(angular_distance_f32x4)
         // relaxed_laneselect: 1 instruction (vblendvps) vs 3 (vpand+vpandn+vpor) on x86.
         // Safe because mask is from comparison (all-ones or all-zeros per lane).
-        v128_t safe_sin_angular = wasm_i32x4_relaxed_laneselect(one, sin_angular_distance, coincident_mask);
-        sin_azimuth = wasm_f32x4_div(wasm_f32x4_mul(wasm_f32x4_mul(cos_reduced_first, cos_reduced_second), sin_lambda),
-                                     safe_sin_angular);
-        cos_squared_azimuth = wasm_f32x4_relaxed_nmadd(sin_azimuth, sin_azimuth, one);
+        v128_t safe_sin_angular_i32x4 = wasm_i32x4_relaxed_laneselect(one_f32x4, sin_angular_distance_f32x4,
+                                                                      coincident_mask_i32x4);
+        sin_azimuth_f32x4 = wasm_f32x4_div(
+            wasm_f32x4_mul(wasm_f32x4_mul(cos_reduced_first_f32x4, cos_reduced_second_f32x4), sin_lambda_f32x4),
+            safe_sin_angular_i32x4);
+        cos_squared_azimuth_f32x4 = wasm_f32x4_relaxed_nmadd(sin_azimuth_f32x4, sin_azimuth_f32x4, one_f32x4);
 
         // Handle equatorial case: cos^2(a) ~ 0
-        v128_t equatorial_mask = wasm_f32x4_lt(cos_squared_azimuth, epsilon);
-        v128_t safe_cos_sq_azimuth = wasm_i32x4_relaxed_laneselect(one, cos_squared_azimuth, equatorial_mask);
+        v128_t equatorial_mask_f32x4 = wasm_f32x4_lt(cos_squared_azimuth_f32x4, epsilon_f32x4);
+        v128_t safe_cos_sq_azimuth_i32x4 = wasm_i32x4_relaxed_laneselect(one_f32x4, cos_squared_azimuth_f32x4,
+                                                                         equatorial_mask_f32x4);
 
         // cos(2sm) = cos(s) - 2 * sin(U1) * sin(U2) / cos^2(a)
-        v128_t sin_product = wasm_f32x4_mul(sin_reduced_first, sin_reduced_second);
-        cos_double_angular_midpoint = wasm_f32x4_sub(
-            cos_angular_distance, wasm_f32x4_div(wasm_f32x4_mul(two, sin_product), safe_cos_sq_azimuth));
-        cos_double_angular_midpoint = wasm_i32x4_relaxed_laneselect(wasm_f32x4_splat(0.0f), cos_double_angular_midpoint,
-                                                                    equatorial_mask);
+        v128_t sin_product_f32x4 = wasm_f32x4_mul(sin_reduced_first_f32x4, sin_reduced_second_f32x4);
+        cos_double_angular_midpoint_f32x4 = wasm_f32x4_sub(
+            cos_angular_distance_f32x4,
+            wasm_f32x4_div(wasm_f32x4_mul(two_f32x4, sin_product_f32x4), safe_cos_sq_azimuth_i32x4));
+        cos_double_angular_midpoint_f32x4 = wasm_i32x4_relaxed_laneselect(
+            wasm_f32x4_splat(0.0f), cos_double_angular_midpoint_f32x4, equatorial_mask_f32x4);
 
         // C = f/16 * cos^2(a) * (4 + f*(4 - 3*cos^2(a)))
-        v128_t correction_factor = wasm_f32x4_mul(
-            wasm_f32x4_div(flattening, sixteen),
+        v128_t correction_factor_f32x4 = wasm_f32x4_mul(
+            wasm_f32x4_div(flattening_f32x4, sixteen_f32x4),
             wasm_f32x4_mul(
-                cos_squared_azimuth,
-                wasm_f32x4_relaxed_madd(flattening, wasm_f32x4_relaxed_nmadd(three, cos_squared_azimuth, four), four)));
+                cos_squared_azimuth_f32x4,
+                wasm_f32x4_relaxed_madd(flattening_f32x4,
+                                        wasm_f32x4_relaxed_nmadd(three_f32x4, cos_squared_azimuth_f32x4, four_f32x4),
+                                        four_f32x4)));
 
         // l' = L + (1-C) * f * sin(a) * (s + C * sin(s) * (cos(2sm) + C * cos(s) * (-1 + 2 * cos^2(2sm))))
-        v128_t cos_2sm_sq = wasm_f32x4_mul(cos_double_angular_midpoint, cos_double_angular_midpoint);
-        v128_t innermost = wasm_f32x4_relaxed_madd(two, cos_2sm_sq, wasm_f32x4_splat(-1.0f));
-        v128_t middle = wasm_f32x4_relaxed_madd(wasm_f32x4_mul(correction_factor, cos_angular_distance), innermost,
-                                                cos_double_angular_midpoint);
-        v128_t inner = wasm_f32x4_mul(wasm_f32x4_mul(correction_factor, sin_angular_distance), middle);
-
-        v128_t lambda_new = wasm_f32x4_relaxed_madd(
-            wasm_f32x4_mul(wasm_f32x4_mul(wasm_f32x4_sub(one, correction_factor), flattening), sin_azimuth),
-            wasm_f32x4_add(angular_distance, inner), longitude_difference);
+        v128_t cos_2sm_sq_f32x4 = wasm_f32x4_mul(cos_double_angular_midpoint_f32x4, cos_double_angular_midpoint_f32x4);
+        v128_t innermost_f32x4 = wasm_f32x4_relaxed_madd(two_f32x4, cos_2sm_sq_f32x4, wasm_f32x4_splat(-1.0f));
+        v128_t middle_f32x4 = wasm_f32x4_relaxed_madd(
+            wasm_f32x4_mul(correction_factor_f32x4, cos_angular_distance_f32x4), innermost_f32x4,
+            cos_double_angular_midpoint_f32x4);
+        v128_t inner_f32x4 = wasm_f32x4_mul(wasm_f32x4_mul(correction_factor_f32x4, sin_angular_distance_f32x4),
+                                            middle_f32x4);
+
+        v128_t lambda_new_f32x4 = wasm_f32x4_relaxed_madd(
+            wasm_f32x4_mul(wasm_f32x4_mul(wasm_f32x4_sub(one_f32x4, correction_factor_f32x4), flattening_f32x4),
+                           sin_azimuth_f32x4),
+            wasm_f32x4_add(angular_distance_f32x4, inner_f32x4), longitude_difference_f32x4);
 
         // Check convergence: |l - l'| < threshold
-        v128_t lambda_diff = wasm_f32x4_sub(lambda_new, lambda);
-        v128_t lambda_diff_abs = wasm_f32x4_abs(lambda_diff);
-        v128_t newly_converged = wasm_f32x4_lt(lambda_diff_abs, convergence_threshold);
-        converged_mask = wasm_v128_or(converged_mask, newly_converged);
+        v128_t lambda_diff_f32x4 = wasm_f32x4_sub(lambda_new_f32x4, lambda_f32x4);
+        v128_t lambda_diff_abs_f32x4 = wasm_f32x4_abs(lambda_diff_f32x4);
+        v128_t newly_converged_f32x4 = wasm_f32x4_lt(lambda_diff_abs_f32x4, convergence_threshold_f32x4);
+        converged_mask_i32x4 = wasm_v128_or(converged_mask_i32x4, newly_converged_f32x4);
 
-        // Only update lambda for non-converged lanes
+        // Only update lambda_f32x4 for non-converged lanes
         // relaxed_laneselect: 1 instruction (vblendvps) vs 3 (vpand+vpandn+vpor) on x86.
         // Safe because mask is from comparison (all-ones or all-zeros per lane).
-        lambda = wasm_i32x4_relaxed_laneselect(lambda, lambda_new, converged_mask);
+        lambda_f32x4 = wasm_i32x4_relaxed_laneselect(lambda_f32x4, lambda_new_f32x4, converged_mask_i32x4);
     }
 
     // Final distance calculation
-    v128_t a_sq = wasm_f32x4_mul(equatorial_radius, equatorial_radius);
-    v128_t b_sq = wasm_f32x4_mul(polar_radius, polar_radius);
-    v128_t u_squared = wasm_f32x4_div(wasm_f32x4_mul(cos_squared_azimuth, wasm_f32x4_sub(a_sq, b_sq)), b_sq);
+    v128_t a_sq_f32x4 = wasm_f32x4_mul(equatorial_radius_f32x4, equatorial_radius_f32x4);
+    v128_t b_sq_f32x4 = wasm_f32x4_mul(polar_radius_f32x4, polar_radius_f32x4);
+    v128_t u_squared_f32x4 = wasm_f32x4_div(
+        wasm_f32x4_mul(cos_squared_azimuth_f32x4, wasm_f32x4_sub(a_sq_f32x4, b_sq_f32x4)), b_sq_f32x4);
 
     // A = 1 + u^2/16384 * (4096 + u^2*(-768 + u^2*(320 - 175*u^2)))
-    v128_t series_a = wasm_f32x4_relaxed_madd(u_squared, wasm_f32x4_splat(-175.0f), wasm_f32x4_splat(320.0f));
-    series_a = wasm_f32x4_relaxed_madd(u_squared, series_a, wasm_f32x4_splat(-768.0f));
-    series_a = wasm_f32x4_relaxed_madd(u_squared, series_a, wasm_f32x4_splat(4096.0f));
-    series_a = wasm_f32x4_relaxed_madd(wasm_f32x4_div(u_squared, wasm_f32x4_splat(16384.0f)), series_a, one);
+    v128_t series_a_f32x4 = wasm_f32x4_relaxed_madd(u_squared_f32x4, wasm_f32x4_splat(-175.0f),
+                                                    wasm_f32x4_splat(320.0f));
+    series_a_f32x4 = wasm_f32x4_relaxed_madd(u_squared_f32x4, series_a_f32x4, wasm_f32x4_splat(-768.0f));
+    series_a_f32x4 = wasm_f32x4_relaxed_madd(u_squared_f32x4, series_a_f32x4, wasm_f32x4_splat(4096.0f));
+    series_a_f32x4 = wasm_f32x4_relaxed_madd(wasm_f32x4_div(u_squared_f32x4, wasm_f32x4_splat(16384.0f)),
+                                             series_a_f32x4, one_f32x4);
 
     // B = u^2/1024 * (256 + u^2*(-128 + u^2*(74 - 47*u^2)))
-    v128_t series_b = wasm_f32x4_relaxed_madd(u_squared, wasm_f32x4_splat(-47.0f), wasm_f32x4_splat(74.0f));
-    series_b = wasm_f32x4_relaxed_madd(u_squared, series_b, wasm_f32x4_splat(-128.0f));
-    series_b = wasm_f32x4_relaxed_madd(u_squared, series_b, wasm_f32x4_splat(256.0f));
-    series_b = wasm_f32x4_mul(wasm_f32x4_div(u_squared, wasm_f32x4_splat(1024.0f)), series_b);
+    v128_t series_b_f32x4 = wasm_f32x4_relaxed_madd(u_squared_f32x4, wasm_f32x4_splat(-47.0f), wasm_f32x4_splat(74.0f));
+    series_b_f32x4 = wasm_f32x4_relaxed_madd(u_squared_f32x4, series_b_f32x4, wasm_f32x4_splat(-128.0f));
+    series_b_f32x4 = wasm_f32x4_relaxed_madd(u_squared_f32x4, series_b_f32x4, wasm_f32x4_splat(256.0f));
+    series_b_f32x4 = wasm_f32x4_mul(wasm_f32x4_div(u_squared_f32x4, wasm_f32x4_splat(1024.0f)), series_b_f32x4);
 
     // Delta-sigma calculation
-    v128_t cos_2sm_sq = wasm_f32x4_mul(cos_double_angular_midpoint, cos_double_angular_midpoint);
-    v128_t sin_sq = wasm_f32x4_mul(sin_angular_distance, sin_angular_distance);
-    v128_t term1 = wasm_f32x4_relaxed_madd(two, cos_2sm_sq, wasm_f32x4_splat(-1.0f));
-    term1 = wasm_f32x4_mul(cos_angular_distance, term1);
-    v128_t term2 = wasm_f32x4_relaxed_madd(four, sin_sq, wasm_f32x4_splat(-3.0f));
-    v128_t term3 = wasm_f32x4_relaxed_madd(four, cos_2sm_sq, wasm_f32x4_splat(-3.0f));
-    term2 = wasm_f32x4_mul(wasm_f32x4_mul(wasm_f32x4_div(series_b, six), cos_double_angular_midpoint),
-                           wasm_f32x4_mul(term2, term3));
-    v128_t delta_sigma = wasm_f32x4_mul(
-        series_b, wasm_f32x4_mul(sin_angular_distance, wasm_f32x4_add(cos_double_angular_midpoint,
-                                                                      wasm_f32x4_mul(wasm_f32x4_div(series_b, four),
-                                                                                     wasm_f32x4_sub(term1, term2)))));
+    v128_t cos_2sm_sq_f32x4 = wasm_f32x4_mul(cos_double_angular_midpoint_f32x4, cos_double_angular_midpoint_f32x4);
+    v128_t sin_sq_f32x4 = wasm_f32x4_mul(sin_angular_distance_f32x4, sin_angular_distance_f32x4);
+    v128_t term1_f32x4 = wasm_f32x4_relaxed_madd(two_f32x4, cos_2sm_sq_f32x4, wasm_f32x4_splat(-1.0f));
+    term1_f32x4 = wasm_f32x4_mul(cos_angular_distance_f32x4, term1_f32x4);
+    v128_t term2_f32x4 = wasm_f32x4_relaxed_madd(four_f32x4, sin_sq_f32x4, wasm_f32x4_splat(-3.0f));
+    v128_t term3_f32x4 = wasm_f32x4_relaxed_madd(four_f32x4, cos_2sm_sq_f32x4, wasm_f32x4_splat(-3.0f));
+    term2_f32x4 = wasm_f32x4_mul(
+        wasm_f32x4_mul(wasm_f32x4_div(series_b_f32x4, six_f32x4), cos_double_angular_midpoint_f32x4),
+        wasm_f32x4_mul(term2_f32x4, term3_f32x4));
+    v128_t delta_sigma_f32x4 = wasm_f32x4_mul(
+        series_b_f32x4, wasm_f32x4_mul(sin_angular_distance_f32x4,
+                                       wasm_f32x4_add(cos_double_angular_midpoint_f32x4,
+                                                      wasm_f32x4_mul(wasm_f32x4_div(series_b_f32x4, four_f32x4),
+                                                                     wasm_f32x4_sub(term1_f32x4, term2_f32x4)))));
 
     // s = b * A * (s - ds)
-    v128_t distances = wasm_f32x4_mul(wasm_f32x4_mul(polar_radius, series_a),
-                                      wasm_f32x4_sub(angular_distance, delta_sigma));
+    v128_t distances_f32x4 = wasm_f32x4_mul(wasm_f32x4_mul(polar_radius_f32x4, series_a_f32x4),
+                                            wasm_f32x4_sub(angular_distance_f32x4, delta_sigma_f32x4));
 
     // Set coincident points to zero
     // relaxed_laneselect: 1 instruction (vblendvps) vs 3 (vpand+vpandn+vpor) on x86.
     // Safe because mask is from comparison (all-ones or all-zeros per lane).
-    distances = wasm_i32x4_relaxed_laneselect(wasm_f32x4_splat(0.0f), distances, coincident_mask);
+    distances_f32x4 = wasm_i32x4_relaxed_laneselect(wasm_f32x4_splat(0.0f), distances_f32x4, coincident_mask_i32x4);
 
-    return distances;
+    return distances_f32x4;
 }
 
 NK_PUBLIC void nk_vincenty_f32_v128relaxed(         //
@@ -575,14 +614,14 @@ NK_PUBLIC void nk_vincenty_f32_v128relaxed(         //
     nk_size_t n, nk_f32_t *results) {
 
     while (n >= 4) {
-        v128_t first_latitudes = wasm_v128_load(a_lats);
-        v128_t first_longitudes = wasm_v128_load(a_lons);
-        v128_t second_latitudes = wasm_v128_load(b_lats);
-        v128_t second_longitudes = wasm_v128_load(b_lons);
+        v128_t first_latitudes_f32x4 = wasm_v128_load(a_lats);
+        v128_t first_longitudes_f32x4 = wasm_v128_load(a_lons);
+        v128_t second_latitudes_f32x4 = wasm_v128_load(b_lats);
+        v128_t second_longitudes_f32x4 = wasm_v128_load(b_lons);
 
-        v128_t distances = nk_vincenty_f32x4_v128relaxed_(first_latitudes, first_longitudes, second_latitudes,
-                                                          second_longitudes);
-        wasm_v128_store(results, distances);
+        v128_t distances_f32x4 = nk_vincenty_f32x4_v128relaxed_(first_latitudes_f32x4, first_longitudes_f32x4,
+                                                                second_latitudes_f32x4, second_longitudes_f32x4);
+        wasm_v128_store(results, distances_f32x4);
 
         a_lats += 4, a_lons += 4, b_lats += 4, b_lons += 4, results += 4, n -= 4;
     }
@@ -594,9 +633,9 @@ NK_PUBLIC void nk_vincenty_f32_v128relaxed(         //
         nk_partial_load_b32x4_serial_(a_lons, &a_lon_vec, n);
         nk_partial_load_b32x4_serial_(b_lats, &b_lat_vec, n);
         nk_partial_load_b32x4_serial_(b_lons, &b_lon_vec, n);
-        v128_t distances = nk_vincenty_f32x4_v128relaxed_(a_lat_vec.v128, a_lon_vec.v128, b_lat_vec.v128,
-                                                          b_lon_vec.v128);
-        result_vec.v128 = distances;
+        v128_t distances_f32x4 = nk_vincenty_f32x4_v128relaxed_(a_lat_vec.v128, a_lon_vec.v128, b_lat_vec.v128,
+                                                                b_lon_vec.v128);
+        result_vec.v128 = distances_f32x4;
         nk_partial_store_b32x4_serial_(&result_vec, results, n);
     }
 }