diff -ruN a/common/mc.c b/common/mc.c
--- a/common/mc.c	2026-10-08 15:16:57
+++ b/common/mc.c	2026-10-08 15:17:11
@@ -25,6 +25,7 @@
  *****************************************************************************/
 
 #include "common.h"
+#include <math.h>
 
 #if HAVE_MMX
 #include "x86/mc.h"
@@ -524,6 +525,86 @@
     }
 }
 
+
+#if HV_AARCH64_MBTREE_EXACT
+/* Verified (Eval 3 Builder B69, 2026-10-08): an exact C model of x264's own aarch64 kernel mbtree_propagate_cost_neon
+ * (common/aarch64/mc-a.S), so that a Windows x86-64 build makes the same encoding decisions as the macOS arm64 build.
+ * It follows the NEON instruction sequence step by step: frecpe (the Arm reciprocal estimate, FPRecipEstimate with
+ * FPCR.AH = 0), frecps (fused 2 - a*b), fmla (fused multiply-add), fmul, fcvtns (round to nearest even, saturating) and
+ * sqxtn (saturating narrow). Compiled without fast-math; fmaf() needs FMA hardware (-mfma). */
+#pragma GCC push_options
+#pragma GCC optimize ("no-fast-math", "fp-contract=off")
+typedef union { float f; uint32_t u; } hv_f32;
+static float hv_frecpe( float x )
+{
+    hv_f32 in = { x }, out;
+    uint32_t sign = in.u & 0x80000000u, exp = (in.u >> 23) & 0xff, frac = in.u & 0x7fffff;
+    if( exp == 0xff )                                  /* NaN stays NaN, +-inf gives +-0 */
+    {
+        if( frac ) { out.u = in.u | 0x400000u; return out.f; }
+        out.u = sign; return out.f;
+    }
+    if( exp == 0 && frac == 0 ) { out.u = sign | 0x7f800000u; return out.f; }
+    int e = (int)exp;
+    if( e == 0 )                                       /* denormal input */
+    {
+        if( !(frac & 0x400000u) ) { e = -1; frac = (frac << 2) & 0x7fffffu; }
+        else frac = (frac << 1) & 0x7fffffu;
+    }
+    uint32_t a = 256u + (frac >> 15);                  /* '1':fraction<22:15> */
+    a = a * 2 + 1;
+    uint32_t b = (1u << 19) / a;
+    uint32_t r = (b + 1) >> 1;                         /* 256..511 */
+    int rexp = 253 - e;
+    uint32_t f = (r & 0xffu) << 15;
+    if( rexp == 0 ) f = 0x400000u | (f >> 1);
+    else if( rexp == -1 ) { f = 0x200000u | (f >> 2); rexp = 0; }
+    if( rexp >= 255 ) { out.u = sign | 0x7f800000u; return out.f; }  /* not reached for x264's inputs */
+    out.u = sign | ((uint32_t)rexp << 23) | f;
+    return out.f;
+}
+static float hv_frecps( float a, float b )
+{
+    hv_f32 ua = { a }, ub = { b };
+    int ainf = (ua.u & 0x7fffffffu) == 0x7f800000u, binf = (ub.u & 0x7fffffffu) == 0x7f800000u;
+    int azero = (ua.u & 0x7fffffffu) == 0, bzero = (ub.u & 0x7fffffffu) == 0;
+    if( (ainf && bzero) || (azero && binf) ) return 2.0f;
+    return fmaf( -a, b, 2.0f );
+}
+static int32_t hv_fcvtns( float x )
+{
+    hv_f32 u = { x };
+    if( (u.u & 0x7fffffffu) > 0x7f800000u ) return 0;   /* NaN */
+    if( x >= 2147483648.0f ) return INT32_MAX;
+    if( x < -2147483648.0f ) return INT32_MIN;
+    return (int32_t)lrintf( x );                       /* default rounding: to nearest, ties to even */
+}
+static void mbtree_propagate_cost_aarch64_exact( int16_t *dst, uint16_t *propagate_in, uint16_t *intra_costs,
+                                                 uint16_t *inter_costs, uint16_t *inv_qscales, float *fps_factor, int len )
+{
+    float fps = *fps_factor;
+    for( int i = 0; i < len; i++ )
+    {
+        uint32_t intra = intra_costs[i];
+        uint32_t inter = inter_costs[i] & 0x3fffu;     /* bic #0xc0, lsl #8 */
+        if( inter > intra ) inter = intra;             /* umin */
+        float f_iq    = (float)(intra * (uint32_t)inv_qscales[i]);  /* umull + ucvtf */
+        float f_num   = (float)(intra - inter);
+        float f_denom = (float)intra;
+        float f_in    = (float)propagate_in[i];
+        float r  = hv_frecpe( f_denom );
+        float s  = hv_frecps( r, f_denom );
+        float amount = fmaf( f_iq, fps, f_in );        /* fmla */
+        float r2 = r * s;
+        float t  = amount * f_num;
+        float v  = t * r2;
+        int32_t q = hv_fcvtns( v );
+        dst[i] = q > 32767 ? 32767 : q < -32768 ? -32768 : (int16_t)q;   /* sqxtn */
+    }
+}
+#pragma GCC pop_options
+#endif
+
 static void mbtree_propagate_list( x264_t *h, uint16_t *ref_costs, int16_t (*mvs)[2],
                                    int16_t *propagate_amount, uint16_t *lowres_costs,
                                    int bipred_weight, int mb_y, int len, int list )
@@ -694,6 +775,9 @@
     x264_mc_init_loongarch( cpu, pf );
 #endif
 
+#if HV_AARCH64_MBTREE_EXACT
+    pf->mbtree_propagate_cost = mbtree_propagate_cost_aarch64_exact;
+#endif
     if( cpu_independent )
     {
         pf->mbtree_propagate_cost = mbtree_propagate_cost;