Update prebuilts for RS compat lib.

Change-Id: Ieb867f63b27792d1c309952e9d86bc719bfadcd3

1 files changed, 430 insertions, 430 deletions

diff --git a/renderscript/clang-include/emmintrin.h b/renderscript/clang-include/emmintrin.h
index 91395ed..e18fae4 100644
--- a/renderscript/clang-include/emmintrin.h
+++ b/renderscript/clang-include/emmintrin.h
@@ -40,507 +40,507 @@ typedef short __v8hi __attribute__((__vector_size__(16)));
 typedef char __v16qi __attribute__((__vector_size__(16)));
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_add_sd(__m128d a, __m128d b)
+_mm_add_sd(__m128d __a, __m128d __b)
 {
-  a[0] += b[0];
-  return a;
+  __a[0] += __b[0];
+  return __a;
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_add_pd(__m128d a, __m128d b)
+_mm_add_pd(__m128d __a, __m128d __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_sub_sd(__m128d a, __m128d b)
+_mm_sub_sd(__m128d __a, __m128d __b)
 {
-  a[0] -= b[0];
-  return a;
+  __a[0] -= __b[0];
+  return __a;
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_sub_pd(__m128d a, __m128d b)
+_mm_sub_pd(__m128d __a, __m128d __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_mul_sd(__m128d a, __m128d b)
+_mm_mul_sd(__m128d __a, __m128d __b)
 {
-  a[0] *= b[0];
-  return a;
+  __a[0] *= __b[0];
+  return __a;
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_mul_pd(__m128d a, __m128d b)
+_mm_mul_pd(__m128d __a, __m128d __b)
 {
-  return a * b;
+  return __a * __b;
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_div_sd(__m128d a, __m128d b)
+_mm_div_sd(__m128d __a, __m128d __b)
 {
-  a[0] /= b[0];
-  return a;
+  __a[0] /= __b[0];
+  return __a;
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_div_pd(__m128d a, __m128d b)
+_mm_div_pd(__m128d __a, __m128d __b)
 {
-  return a / b;
+  return __a / __b;
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_sqrt_sd(__m128d a, __m128d b)
+_mm_sqrt_sd(__m128d __a, __m128d __b)
 {
-  __m128d c = __builtin_ia32_sqrtsd(b);
-  return (__m128d) { c[0], a[1] };
+  __m128d __c = __builtin_ia32_sqrtsd(__b);
+  return (__m128d) { __c[0], __a[1] };
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_sqrt_pd(__m128d a)
+_mm_sqrt_pd(__m128d __a)
 {
-  return __builtin_ia32_sqrtpd(a);
+  return __builtin_ia32_sqrtpd(__a);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_min_sd(__m128d a, __m128d b)
+_mm_min_sd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_minsd(a, b);
+  return __builtin_ia32_minsd(__a, __b);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_min_pd(__m128d a, __m128d b)
+_mm_min_pd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_minpd(a, b);
+  return __builtin_ia32_minpd(__a, __b);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_max_sd(__m128d a, __m128d b)
+_mm_max_sd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_maxsd(a, b);
+  return __builtin_ia32_maxsd(__a, __b);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_max_pd(__m128d a, __m128d b)
+_mm_max_pd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_maxpd(a, b);
+  return __builtin_ia32_maxpd(__a, __b);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_and_pd(__m128d a, __m128d b)
+_mm_and_pd(__m128d __a, __m128d __b)
 {
-  return (__m128d)((__v4si)a & (__v4si)b);
+  return (__m128d)((__v4si)__a & (__v4si)__b);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_andnot_pd(__m128d a, __m128d b)
+_mm_andnot_pd(__m128d __a, __m128d __b)
 {
-  return (__m128d)(~(__v4si)a & (__v4si)b);
+  return (__m128d)(~(__v4si)__a & (__v4si)__b);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_or_pd(__m128d a, __m128d b)
+_mm_or_pd(__m128d __a, __m128d __b)
 {
-  return (__m128d)((__v4si)a | (__v4si)b);
+  return (__m128d)((__v4si)__a | (__v4si)__b);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_xor_pd(__m128d a, __m128d b)
+_mm_xor_pd(__m128d __a, __m128d __b)
 {
-  return (__m128d)((__v4si)a ^ (__v4si)b);
+  return (__m128d)((__v4si)__a ^ (__v4si)__b);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpeq_pd(__m128d a, __m128d b)
+_mm_cmpeq_pd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmppd(a, b, 0);
+  return (__m128d)__builtin_ia32_cmppd(__a, __b, 0);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmplt_pd(__m128d a, __m128d b)
+_mm_cmplt_pd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmppd(a, b, 1);
+  return (__m128d)__builtin_ia32_cmppd(__a, __b, 1);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmple_pd(__m128d a, __m128d b)
+_mm_cmple_pd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmppd(a, b, 2);
+  return (__m128d)__builtin_ia32_cmppd(__a, __b, 2);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpgt_pd(__m128d a, __m128d b)
+_mm_cmpgt_pd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmppd(b, a, 1);
+  return (__m128d)__builtin_ia32_cmppd(__b, __a, 1);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpge_pd(__m128d a, __m128d b)
+_mm_cmpge_pd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmppd(b, a, 2);
+  return (__m128d)__builtin_ia32_cmppd(__b, __a, 2);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpord_pd(__m128d a, __m128d b)
+_mm_cmpord_pd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmppd(a, b, 7);
+  return (__m128d)__builtin_ia32_cmppd(__a, __b, 7);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpunord_pd(__m128d a, __m128d b)
+_mm_cmpunord_pd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmppd(a, b, 3);
+  return (__m128d)__builtin_ia32_cmppd(__a, __b, 3);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpneq_pd(__m128d a, __m128d b)
+_mm_cmpneq_pd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmppd(a, b, 4);
+  return (__m128d)__builtin_ia32_cmppd(__a, __b, 4);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpnlt_pd(__m128d a, __m128d b)
+_mm_cmpnlt_pd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmppd(a, b, 5);
+  return (__m128d)__builtin_ia32_cmppd(__a, __b, 5);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpnle_pd(__m128d a, __m128d b)
+_mm_cmpnle_pd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmppd(a, b, 6);
+  return (__m128d)__builtin_ia32_cmppd(__a, __b, 6);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpngt_pd(__m128d a, __m128d b)
+_mm_cmpngt_pd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmppd(b, a, 5);
+  return (__m128d)__builtin_ia32_cmppd(__b, __a, 5);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpnge_pd(__m128d a, __m128d b)
+_mm_cmpnge_pd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmppd(b, a, 6);
+  return (__m128d)__builtin_ia32_cmppd(__b, __a, 6);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpeq_sd(__m128d a, __m128d b)
+_mm_cmpeq_sd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmpsd(a, b, 0);
+  return (__m128d)__builtin_ia32_cmpsd(__a, __b, 0);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmplt_sd(__m128d a, __m128d b)
+_mm_cmplt_sd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmpsd(a, b, 1);
+  return (__m128d)__builtin_ia32_cmpsd(__a, __b, 1);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmple_sd(__m128d a, __m128d b)
+_mm_cmple_sd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmpsd(a, b, 2);
+  return (__m128d)__builtin_ia32_cmpsd(__a, __b, 2);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpgt_sd(__m128d a, __m128d b)
+_mm_cmpgt_sd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmpsd(b, a, 1);
+  return (__m128d)__builtin_ia32_cmpsd(__b, __a, 1);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpge_sd(__m128d a, __m128d b)
+_mm_cmpge_sd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmpsd(b, a, 2);
+  return (__m128d)__builtin_ia32_cmpsd(__b, __a, 2);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpord_sd(__m128d a, __m128d b)
+_mm_cmpord_sd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmpsd(a, b, 7);
+  return (__m128d)__builtin_ia32_cmpsd(__a, __b, 7);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpunord_sd(__m128d a, __m128d b)
+_mm_cmpunord_sd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmpsd(a, b, 3);
+  return (__m128d)__builtin_ia32_cmpsd(__a, __b, 3);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpneq_sd(__m128d a, __m128d b)
+_mm_cmpneq_sd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmpsd(a, b, 4);
+  return (__m128d)__builtin_ia32_cmpsd(__a, __b, 4);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpnlt_sd(__m128d a, __m128d b)
+_mm_cmpnlt_sd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmpsd(a, b, 5);
+  return (__m128d)__builtin_ia32_cmpsd(__a, __b, 5);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpnle_sd(__m128d a, __m128d b)
+_mm_cmpnle_sd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmpsd(a, b, 6);
+  return (__m128d)__builtin_ia32_cmpsd(__a, __b, 6);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpngt_sd(__m128d a, __m128d b)
+_mm_cmpngt_sd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmpsd(b, a, 5);
+  return (__m128d)__builtin_ia32_cmpsd(__b, __a, 5);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cmpnge_sd(__m128d a, __m128d b)
+_mm_cmpnge_sd(__m128d __a, __m128d __b)
 {
-  return (__m128d)__builtin_ia32_cmpsd(b, a, 6);
+  return (__m128d)__builtin_ia32_cmpsd(__b, __a, 6);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_comieq_sd(__m128d a, __m128d b)
+_mm_comieq_sd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_comisdeq(a, b);
+  return __builtin_ia32_comisdeq(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_comilt_sd(__m128d a, __m128d b)
+_mm_comilt_sd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_comisdlt(a, b);
+  return __builtin_ia32_comisdlt(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_comile_sd(__m128d a, __m128d b)
+_mm_comile_sd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_comisdle(a, b);
+  return __builtin_ia32_comisdle(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_comigt_sd(__m128d a, __m128d b)
+_mm_comigt_sd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_comisdgt(a, b);
+  return __builtin_ia32_comisdgt(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_comige_sd(__m128d a, __m128d b)
+_mm_comige_sd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_comisdge(a, b);
+  return __builtin_ia32_comisdge(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_comineq_sd(__m128d a, __m128d b)
+_mm_comineq_sd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_comisdneq(a, b);
+  return __builtin_ia32_comisdneq(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_ucomieq_sd(__m128d a, __m128d b)
+_mm_ucomieq_sd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_ucomisdeq(a, b);
+  return __builtin_ia32_ucomisdeq(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_ucomilt_sd(__m128d a, __m128d b)
+_mm_ucomilt_sd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_ucomisdlt(a, b);
+  return __builtin_ia32_ucomisdlt(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_ucomile_sd(__m128d a, __m128d b)
+_mm_ucomile_sd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_ucomisdle(a, b);
+  return __builtin_ia32_ucomisdle(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_ucomigt_sd(__m128d a, __m128d b)
+_mm_ucomigt_sd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_ucomisdgt(a, b);
+  return __builtin_ia32_ucomisdgt(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_ucomige_sd(__m128d a, __m128d b)
+_mm_ucomige_sd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_ucomisdge(a, b);
+  return __builtin_ia32_ucomisdge(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_ucomineq_sd(__m128d a, __m128d b)
+_mm_ucomineq_sd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_ucomisdneq(a, b);
+  return __builtin_ia32_ucomisdneq(__a, __b);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cvtpd_ps(__m128d a)
+_mm_cvtpd_ps(__m128d __a)
 {
-  return __builtin_ia32_cvtpd2ps(a);
+  return __builtin_ia32_cvtpd2ps(__a);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cvtps_pd(__m128 a)
+_mm_cvtps_pd(__m128 __a)
 {
-  return __builtin_ia32_cvtps2pd(a);
+  return __builtin_ia32_cvtps2pd(__a);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cvtepi32_pd(__m128i a)
+_mm_cvtepi32_pd(__m128i __a)
 {
-  return __builtin_ia32_cvtdq2pd((__v4si)a);
+  return __builtin_ia32_cvtdq2pd((__v4si)__a);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_cvtpd_epi32(__m128d a)
+_mm_cvtpd_epi32(__m128d __a)
 {
-  return __builtin_ia32_cvtpd2dq(a);
+  return __builtin_ia32_cvtpd2dq(__a);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_cvtsd_si32(__m128d a)
+_mm_cvtsd_si32(__m128d __a)
 {
-  return __builtin_ia32_cvtsd2si(a);
+  return __builtin_ia32_cvtsd2si(__a);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cvtsd_ss(__m128 a, __m128d b)
+_mm_cvtsd_ss(__m128 __a, __m128d __b)
 {
-  a[0] = b[0];
-  return a;
+  __a[0] = __b[0];
+  return __a;
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cvtsi32_sd(__m128d a, int b)
+_mm_cvtsi32_sd(__m128d __a, int __b)
 {
-  a[0] = b;
-  return a;
+  __a[0] = __b;
+  return __a;
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cvtss_sd(__m128d a, __m128 b)
+_mm_cvtss_sd(__m128d __a, __m128 __b)
 {
-  a[0] = b[0];
-  return a;
+  __a[0] = __b[0];
+  return __a;
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_cvttpd_epi32(__m128d a)
+_mm_cvttpd_epi32(__m128d __a)
 {
-  return (__m128i)__builtin_ia32_cvttpd2dq(a);
+  return (__m128i)__builtin_ia32_cvttpd2dq(__a);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_cvttsd_si32(__m128d a)
+_mm_cvttsd_si32(__m128d __a)
 {
-  return a[0];
+  return __a[0];
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_cvtpd_pi32(__m128d a)
+_mm_cvtpd_pi32(__m128d __a)
 {
-  return (__m64)__builtin_ia32_cvtpd2pi(a);
+  return (__m64)__builtin_ia32_cvtpd2pi(__a);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_cvttpd_pi32(__m128d a)
+_mm_cvttpd_pi32(__m128d __a)
 {
-  return (__m64)__builtin_ia32_cvttpd2pi(a);
+  return (__m64)__builtin_ia32_cvttpd2pi(__a);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cvtpi32_pd(__m64 a)
+_mm_cvtpi32_pd(__m64 __a)
 {
-  return __builtin_ia32_cvtpi2pd((__v2si)a);
+  return __builtin_ia32_cvtpi2pd((__v2si)__a);
 }
 
 static __inline__ double __attribute__((__always_inline__, __nodebug__))
-_mm_cvtsd_f64(__m128d a)
+_mm_cvtsd_f64(__m128d __a)
 {
-  return a[0];
+  return __a[0];
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_load_pd(double const *dp)
+_mm_load_pd(double const *__dp)
 {
-  return *(__m128d*)dp;
+  return *(__m128d*)__dp;
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_load1_pd(double const *dp)
+_mm_load1_pd(double const *__dp)
 {
   struct __mm_load1_pd_struct {
-    double u;
+    double __u;
   } __attribute__((__packed__, __may_alias__));
-  double u = ((struct __mm_load1_pd_struct*)dp)->u;
-  return (__m128d){ u, u };
+  double __u = ((struct __mm_load1_pd_struct*)__dp)->__u;
+  return (__m128d){ __u, __u };
 }
 
 #define        _mm_load_pd1(dp)        _mm_load1_pd(dp)
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_loadr_pd(double const *dp)
+_mm_loadr_pd(double const *__dp)
 {
-  __m128d u = *(__m128d*)dp;
-  return __builtin_shufflevector(u, u, 1, 0);
+  __m128d __u = *(__m128d*)__dp;
+  return __builtin_shufflevector(__u, __u, 1, 0);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_loadu_pd(double const *dp)
+_mm_loadu_pd(double const *__dp)
 {
   struct __loadu_pd {
-    __m128d v;
+    __m128d __v;
   } __attribute__((packed, may_alias));
-  return ((struct __loadu_pd*)dp)->v;
+  return ((struct __loadu_pd*)__dp)->__v;
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_load_sd(double const *dp)
+_mm_load_sd(double const *__dp)
 {
   struct __mm_load_sd_struct {
-    double u;
+    double __u;
   } __attribute__((__packed__, __may_alias__));
-  double u = ((struct __mm_load_sd_struct*)dp)->u;
-  return (__m128d){ u, 0 };
+  double __u = ((struct __mm_load_sd_struct*)__dp)->__u;
+  return (__m128d){ __u, 0 };
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_loadh_pd(__m128d a, double const *dp)
+_mm_loadh_pd(__m128d __a, double const *__dp)
 {
   struct __mm_loadh_pd_struct {
-    double u;
+    double __u;
   } __attribute__((__packed__, __may_alias__));
-  double u = ((struct __mm_loadh_pd_struct*)dp)->u;
-  return (__m128d){ a[0], u };
+  double __u = ((struct __mm_loadh_pd_struct*)__dp)->__u;
+  return (__m128d){ __a[0], __u };
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_loadl_pd(__m128d a, double const *dp)
+_mm_loadl_pd(__m128d __a, double const *__dp)
 {
   struct __mm_loadl_pd_struct {
-    double u;
+    double __u;
   } __attribute__((__packed__, __may_alias__));
-  double u = ((struct __mm_loadl_pd_struct*)dp)->u;
-  return (__m128d){ u, a[1] }; 
+  double __u = ((struct __mm_loadl_pd_struct*)__dp)->__u;
+  return (__m128d){ __u, __a[1] };
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_set_sd(double w)
+_mm_set_sd(double __w)
 {
-  return (__m128d){ w, 0 };
+  return (__m128d){ __w, 0 };
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_set1_pd(double w)
+_mm_set1_pd(double __w)
 {
-  return (__m128d){ w, w };
+  return (__m128d){ __w, __w };
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_set_pd(double w, double x)
+_mm_set_pd(double __w, double __x)
 {
-  return (__m128d){ x, w };
+  return (__m128d){ __x, __w };
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_setr_pd(double w, double x)
+_mm_setr_pd(double __w, double __x)
 {
-  return (__m128d){ w, x };
+  return (__m128d){ __w, __x };
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
@@ -550,275 +550,275 @@ _mm_setzero_pd(void)
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_move_sd(__m128d a, __m128d b)
+_mm_move_sd(__m128d __a, __m128d __b)
 {
-  return (__m128d){ b[0], a[1] };
+  return (__m128d){ __b[0], __a[1] };
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_store_sd(double *dp, __m128d a)
+_mm_store_sd(double *__dp, __m128d __a)
 {
   struct __mm_store_sd_struct {
-    double u;
+    double __u;
   } __attribute__((__packed__, __may_alias__));
-  ((struct __mm_store_sd_struct*)dp)->u = a[0];
+  ((struct __mm_store_sd_struct*)__dp)->__u = __a[0];
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_store1_pd(double *dp, __m128d a)
+_mm_store1_pd(double *__dp, __m128d __a)
 {
   struct __mm_store1_pd_struct {
-    double u[2];
+    double __u[2];
   } __attribute__((__packed__, __may_alias__));
-  ((struct __mm_store1_pd_struct*)dp)->u[0] = a[0];
-  ((struct __mm_store1_pd_struct*)dp)->u[1] = a[0];
+  ((struct __mm_store1_pd_struct*)__dp)->__u[0] = __a[0];
+  ((struct __mm_store1_pd_struct*)__dp)->__u[1] = __a[0];
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_store_pd(double *dp, __m128d a)
+_mm_store_pd(double *__dp, __m128d __a)
 {
-  *(__m128d *)dp = a;
+  *(__m128d *)__dp = __a;
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_storeu_pd(double *dp, __m128d a)
+_mm_storeu_pd(double *__dp, __m128d __a)
 {
-  __builtin_ia32_storeupd(dp, a);
+  __builtin_ia32_storeupd(__dp, __a);
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_storer_pd(double *dp, __m128d a)
+_mm_storer_pd(double *__dp, __m128d __a)
 {
-  a = __builtin_shufflevector(a, a, 1, 0);
-  *(__m128d *)dp = a;
+  __a = __builtin_shufflevector(__a, __a, 1, 0);
+  *(__m128d *)__dp = __a;
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_storeh_pd(double *dp, __m128d a)
+_mm_storeh_pd(double *__dp, __m128d __a)
 {
   struct __mm_storeh_pd_struct {
-    double u;
+    double __u;
   } __attribute__((__packed__, __may_alias__));
-  ((struct __mm_storeh_pd_struct*)dp)->u = a[1];
+  ((struct __mm_storeh_pd_struct*)__dp)->__u = __a[1];
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_storel_pd(double *dp, __m128d a)
+_mm_storel_pd(double *__dp, __m128d __a)
 {
   struct __mm_storeh_pd_struct {
-    double u;
+    double __u;
   } __attribute__((__packed__, __may_alias__));
-  ((struct __mm_storeh_pd_struct*)dp)->u = a[0];
+  ((struct __mm_storeh_pd_struct*)__dp)->__u = __a[0];
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_add_epi8(__m128i a, __m128i b)
+_mm_add_epi8(__m128i __a, __m128i __b)
 {
-  return (__m128i)((__v16qi)a + (__v16qi)b);
+  return (__m128i)((__v16qi)__a + (__v16qi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_add_epi16(__m128i a, __m128i b)
+_mm_add_epi16(__m128i __a, __m128i __b)
 {
-  return (__m128i)((__v8hi)a + (__v8hi)b);
+  return (__m128i)((__v8hi)__a + (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_add_epi32(__m128i a, __m128i b)
+_mm_add_epi32(__m128i __a, __m128i __b)
 {
-  return (__m128i)((__v4si)a + (__v4si)b);
+  return (__m128i)((__v4si)__a + (__v4si)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_add_si64(__m64 a, __m64 b)
+_mm_add_si64(__m64 __a, __m64 __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_add_epi64(__m128i a, __m128i b)
+_mm_add_epi64(__m128i __a, __m128i __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_adds_epi8(__m128i a, __m128i b)
+_mm_adds_epi8(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_paddsb128((__v16qi)a, (__v16qi)b);
+  return (__m128i)__builtin_ia32_paddsb128((__v16qi)__a, (__v16qi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_adds_epi16(__m128i a, __m128i b)
+_mm_adds_epi16(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_paddsw128((__v8hi)a, (__v8hi)b);
+  return (__m128i)__builtin_ia32_paddsw128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_adds_epu8(__m128i a, __m128i b)
+_mm_adds_epu8(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_paddusb128((__v16qi)a, (__v16qi)b);
+  return (__m128i)__builtin_ia32_paddusb128((__v16qi)__a, (__v16qi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_adds_epu16(__m128i a, __m128i b)
+_mm_adds_epu16(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_paddusw128((__v8hi)a, (__v8hi)b);
+  return (__m128i)__builtin_ia32_paddusw128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_avg_epu8(__m128i a, __m128i b)
+_mm_avg_epu8(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_pavgb128((__v16qi)a, (__v16qi)b);
+  return (__m128i)__builtin_ia32_pavgb128((__v16qi)__a, (__v16qi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_avg_epu16(__m128i a, __m128i b)
+_mm_avg_epu16(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_pavgw128((__v8hi)a, (__v8hi)b);
+  return (__m128i)__builtin_ia32_pavgw128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_madd_epi16(__m128i a, __m128i b)
+_mm_madd_epi16(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_pmaddwd128((__v8hi)a, (__v8hi)b);
+  return (__m128i)__builtin_ia32_pmaddwd128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_max_epi16(__m128i a, __m128i b)
+_mm_max_epi16(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_pmaxsw128((__v8hi)a, (__v8hi)b);
+  return (__m128i)__builtin_ia32_pmaxsw128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_max_epu8(__m128i a, __m128i b)
+_mm_max_epu8(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_pmaxub128((__v16qi)a, (__v16qi)b);
+  return (__m128i)__builtin_ia32_pmaxub128((__v16qi)__a, (__v16qi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_min_epi16(__m128i a, __m128i b)
+_mm_min_epi16(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_pminsw128((__v8hi)a, (__v8hi)b);
+  return (__m128i)__builtin_ia32_pminsw128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_min_epu8(__m128i a, __m128i b)
+_mm_min_epu8(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_pminub128((__v16qi)a, (__v16qi)b);
+  return (__m128i)__builtin_ia32_pminub128((__v16qi)__a, (__v16qi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_mulhi_epi16(__m128i a, __m128i b)
+_mm_mulhi_epi16(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_pmulhw128((__v8hi)a, (__v8hi)b);
+  return (__m128i)__builtin_ia32_pmulhw128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_mulhi_epu16(__m128i a, __m128i b)
+_mm_mulhi_epu16(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_pmulhuw128((__v8hi)a, (__v8hi)b);
+  return (__m128i)__builtin_ia32_pmulhuw128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_mullo_epi16(__m128i a, __m128i b)
+_mm_mullo_epi16(__m128i __a, __m128i __b)
 {
-  return (__m128i)((__v8hi)a * (__v8hi)b);
+  return (__m128i)((__v8hi)__a * (__v8hi)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_mul_su32(__m64 a, __m64 b)
+_mm_mul_su32(__m64 __a, __m64 __b)
 {
-  return __builtin_ia32_pmuludq((__v2si)a, (__v2si)b);
+  return __builtin_ia32_pmuludq((__v2si)__a, (__v2si)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_mul_epu32(__m128i a, __m128i b)
+_mm_mul_epu32(__m128i __a, __m128i __b)
 {
-  return __builtin_ia32_pmuludq128((__v4si)a, (__v4si)b);
+  return __builtin_ia32_pmuludq128((__v4si)__a, (__v4si)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_sad_epu8(__m128i a, __m128i b)
+_mm_sad_epu8(__m128i __a, __m128i __b)
 {
-  return __builtin_ia32_psadbw128((__v16qi)a, (__v16qi)b);
+  return __builtin_ia32_psadbw128((__v16qi)__a, (__v16qi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_sub_epi8(__m128i a, __m128i b)
+_mm_sub_epi8(__m128i __a, __m128i __b)
 {
-  return (__m128i)((__v16qi)a - (__v16qi)b);
+  return (__m128i)((__v16qi)__a - (__v16qi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_sub_epi16(__m128i a, __m128i b)
+_mm_sub_epi16(__m128i __a, __m128i __b)
 {
-  return (__m128i)((__v8hi)a - (__v8hi)b);
+  return (__m128i)((__v8hi)__a - (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_sub_epi32(__m128i a, __m128i b)
+_mm_sub_epi32(__m128i __a, __m128i __b)
 {
-  return (__m128i)((__v4si)a - (__v4si)b);
+  return (__m128i)((__v4si)__a - (__v4si)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_sub_si64(__m64 a, __m64 b)
+_mm_sub_si64(__m64 __a, __m64 __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_sub_epi64(__m128i a, __m128i b)
+_mm_sub_epi64(__m128i __a, __m128i __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_subs_epi8(__m128i a, __m128i b)
+_mm_subs_epi8(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_psubsb128((__v16qi)a, (__v16qi)b);
+  return (__m128i)__builtin_ia32_psubsb128((__v16qi)__a, (__v16qi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_subs_epi16(__m128i a, __m128i b)
+_mm_subs_epi16(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_psubsw128((__v8hi)a, (__v8hi)b);
+  return (__m128i)__builtin_ia32_psubsw128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_subs_epu8(__m128i a, __m128i b)
+_mm_subs_epu8(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_psubusb128((__v16qi)a, (__v16qi)b);
+  return (__m128i)__builtin_ia32_psubusb128((__v16qi)__a, (__v16qi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_subs_epu16(__m128i a, __m128i b)
+_mm_subs_epu16(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_psubusw128((__v8hi)a, (__v8hi)b);
+  return (__m128i)__builtin_ia32_psubusw128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_and_si128(__m128i a, __m128i b)
+_mm_and_si128(__m128i __a, __m128i __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_andnot_si128(__m128i a, __m128i b)
+_mm_andnot_si128(__m128i __a, __m128i __b)
 {
-  return ~a & b;
+  return ~__a & __b;
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_or_si128(__m128i a, __m128i b)
+_mm_or_si128(__m128i __a, __m128i __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_xor_si128(__m128i a, __m128i b)
+_mm_xor_si128(__m128i __a, __m128i __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 #define _mm_slli_si128(a, count) __extension__ ({ \
@@ -826,63 +826,63 @@ _mm_xor_si128(__m128i a, __m128i b)
   (__m128i)__builtin_ia32_pslldqi128(__a, (count)*8); })
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_slli_epi16(__m128i a, int count)
+_mm_slli_epi16(__m128i __a, int __count)
 {
-  return (__m128i)__builtin_ia32_psllwi128((__v8hi)a, count);
+  return (__m128i)__builtin_ia32_psllwi128((__v8hi)__a, __count);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_sll_epi16(__m128i a, __m128i count)
+_mm_sll_epi16(__m128i __a, __m128i __count)
 {
-  return (__m128i)__builtin_ia32_psllw128((__v8hi)a, (__v8hi)count);
+  return (__m128i)__builtin_ia32_psllw128((__v8hi)__a, (__v8hi)__count);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_slli_epi32(__m128i a, int count)
+_mm_slli_epi32(__m128i __a, int __count)
 {
-  return (__m128i)__builtin_ia32_pslldi128((__v4si)a, count);
+  return (__m128i)__builtin_ia32_pslldi128((__v4si)__a, __count);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_sll_epi32(__m128i a, __m128i count)
+_mm_sll_epi32(__m128i __a, __m128i __count)
 {
-  return (__m128i)__builtin_ia32_pslld128((__v4si)a, (__v4si)count);
+  return (__m128i)__builtin_ia32_pslld128((__v4si)__a, (__v4si)__count);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_slli_epi64(__m128i a, int count)
+_mm_slli_epi64(__m128i __a, int __count)
 {
-  return __builtin_ia32_psllqi128(a, count);
+  return __builtin_ia32_psllqi128(__a, __count);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_sll_epi64(__m128i a, __m128i count)
+_mm_sll_epi64(__m128i __a, __m128i __count)
 {
-  return __builtin_ia32_psllq128(a, count);
+  return __builtin_ia32_psllq128(__a, __count);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_srai_epi16(__m128i a, int count)
+_mm_srai_epi16(__m128i __a, int __count)
 {
-  return (__m128i)__builtin_ia32_psrawi128((__v8hi)a, count);
+  return (__m128i)__builtin_ia32_psrawi128((__v8hi)__a, __count);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_sra_epi16(__m128i a, __m128i count)
+_mm_sra_epi16(__m128i __a, __m128i __count)
 {
-  return (__m128i)__builtin_ia32_psraw128((__v8hi)a, (__v8hi)count);
+  return (__m128i)__builtin_ia32_psraw128((__v8hi)__a, (__v8hi)__count);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_srai_epi32(__m128i a, int count)
+_mm_srai_epi32(__m128i __a, int __count)
 {
-  return (__m128i)__builtin_ia32_psradi128((__v4si)a, count);
+  return (__m128i)__builtin_ia32_psradi128((__v4si)__a, __count);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_sra_epi32(__m128i a, __m128i count)
+_mm_sra_epi32(__m128i __a, __m128i __count)
 {
-  return (__m128i)__builtin_ia32_psrad128((__v4si)a, (__v4si)count);
+  return (__m128i)__builtin_ia32_psrad128((__v4si)__a, (__v4si)__count);
 }
 
 
@@ -891,188 +891,188 @@ _mm_sra_epi32(__m128i a, __m128i count)
   (__m128i)__builtin_ia32_psrldqi128(__a, (count)*8); })
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_srli_epi16(__m128i a, int count)
+_mm_srli_epi16(__m128i __a, int __count)
 {
-  return (__m128i)__builtin_ia32_psrlwi128((__v8hi)a, count);
+  return (__m128i)__builtin_ia32_psrlwi128((__v8hi)__a, __count);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_srl_epi16(__m128i a, __m128i count)
+_mm_srl_epi16(__m128i __a, __m128i __count)
 {
-  return (__m128i)__builtin_ia32_psrlw128((__v8hi)a, (__v8hi)count);
+  return (__m128i)__builtin_ia32_psrlw128((__v8hi)__a, (__v8hi)__count);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_srli_epi32(__m128i a, int count)
+_mm_srli_epi32(__m128i __a, int __count)
 {
-  return (__m128i)__builtin_ia32_psrldi128((__v4si)a, count);
+  return (__m128i)__builtin_ia32_psrldi128((__v4si)__a, __count);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_srl_epi32(__m128i a, __m128i count)
+_mm_srl_epi32(__m128i __a, __m128i __count)
 {
-  return (__m128i)__builtin_ia32_psrld128((__v4si)a, (__v4si)count);
+  return (__m128i)__builtin_ia32_psrld128((__v4si)__a, (__v4si)__count);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_srli_epi64(__m128i a, int count)
+_mm_srli_epi64(__m128i __a, int __count)
 {
-  return __builtin_ia32_psrlqi128(a, count);
+  return __builtin_ia32_psrlqi128(__a, __count);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_srl_epi64(__m128i a, __m128i count)
+_mm_srl_epi64(__m128i __a, __m128i __count)
 {
-  return __builtin_ia32_psrlq128(a, count);
+  return __builtin_ia32_psrlq128(__a, __count);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_cmpeq_epi8(__m128i a, __m128i b)
+_mm_cmpeq_epi8(__m128i __a, __m128i __b)
 {
-  return (__m128i)((__v16qi)a == (__v16qi)b);
+  return (__m128i)((__v16qi)__a == (__v16qi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_cmpeq_epi16(__m128i a, __m128i b)
+_mm_cmpeq_epi16(__m128i __a, __m128i __b)
 {
-  return (__m128i)((__v8hi)a == (__v8hi)b);
+  return (__m128i)((__v8hi)__a == (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_cmpeq_epi32(__m128i a, __m128i b)
+_mm_cmpeq_epi32(__m128i __a, __m128i __b)
 {
-  return (__m128i)((__v4si)a == (__v4si)b);
+  return (__m128i)((__v4si)__a == (__v4si)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_cmpgt_epi8(__m128i a, __m128i b)
+_mm_cmpgt_epi8(__m128i __a, __m128i __b)
 {
   /* This function always performs a signed comparison, but __v16qi is a char
      which may be signed or unsigned. */
   typedef signed char __v16qs __attribute__((__vector_size__(16)));
-  return (__m128i)((__v16qs)a > (__v16qs)b);
+  return (__m128i)((__v16qs)__a > (__v16qs)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_cmpgt_epi16(__m128i a, __m128i b)
+_mm_cmpgt_epi16(__m128i __a, __m128i __b)
 {
-  return (__m128i)((__v8hi)a > (__v8hi)b);
+  return (__m128i)((__v8hi)__a > (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_cmpgt_epi32(__m128i a, __m128i b)
+_mm_cmpgt_epi32(__m128i __a, __m128i __b)
 {
-  return (__m128i)((__v4si)a > (__v4si)b);
+  return (__m128i)((__v4si)__a > (__v4si)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_cmplt_epi8(__m128i a, __m128i b)
+_mm_cmplt_epi8(__m128i __a, __m128i __b)
 {
-  return _mm_cmpgt_epi8(b,a);
+  return _mm_cmpgt_epi8(__b, __a);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_cmplt_epi16(__m128i a, __m128i b)
+_mm_cmplt_epi16(__m128i __a, __m128i __b)
 {
-  return _mm_cmpgt_epi16(b,a);
+  return _mm_cmpgt_epi16(__b, __a);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_cmplt_epi32(__m128i a, __m128i b)
+_mm_cmplt_epi32(__m128i __a, __m128i __b)
 {
-  return _mm_cmpgt_epi32(b,a);
+  return _mm_cmpgt_epi32(__b, __a);
 }
 
 #ifdef __x86_64__
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_cvtsi64_sd(__m128d a, long long b)
+_mm_cvtsi64_sd(__m128d __a, long long __b)
 {
-  a[0] = b;
-  return a;
+  __a[0] = __b;
+  return __a;
 }
 
 static __inline__ long long __attribute__((__always_inline__, __nodebug__))
-_mm_cvtsd_si64(__m128d a)
+_mm_cvtsd_si64(__m128d __a)
 {
-  return __builtin_ia32_cvtsd2si64(a);
+  return __builtin_ia32_cvtsd2si64(__a);
 }
 
 static __inline__ long long __attribute__((__always_inline__, __nodebug__))
-_mm_cvttsd_si64(__m128d a)
+_mm_cvttsd_si64(__m128d __a)
 {
-  return a[0];
+  return __a[0];
 }
 #endif
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cvtepi32_ps(__m128i a)
+_mm_cvtepi32_ps(__m128i __a)
 {
-  return __builtin_ia32_cvtdq2ps((__v4si)a);
+  return __builtin_ia32_cvtdq2ps((__v4si)__a);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_cvtps_epi32(__m128 a)
+_mm_cvtps_epi32(__m128 __a)
 {
-  return (__m128i)__builtin_ia32_cvtps2dq(a);
+  return (__m128i)__builtin_ia32_cvtps2dq(__a);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_cvttps_epi32(__m128 a)
+_mm_cvttps_epi32(__m128 __a)
 {
-  return (__m128i)__builtin_ia32_cvttps2dq(a);
+  return (__m128i)__builtin_ia32_cvttps2dq(__a);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_cvtsi32_si128(int a)
+_mm_cvtsi32_si128(int __a)
 {
-  return (__m128i)(__v4si){ a, 0, 0, 0 };
+  return (__m128i)(__v4si){ __a, 0, 0, 0 };
 }
 
 #ifdef __x86_64__
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_cvtsi64_si128(long long a)
+_mm_cvtsi64_si128(long long __a)
 {
-  return (__m128i){ a, 0 };
+  return (__m128i){ __a, 0 };
 }
 #endif
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_cvtsi128_si32(__m128i a)
+_mm_cvtsi128_si32(__m128i __a)
 {
-  __v4si b = (__v4si)a;
-  return b[0];
+  __v4si __b = (__v4si)__a;
+  return __b[0];
 }
 
 #ifdef __x86_64__
 static __inline__ long long __attribute__((__always_inline__, __nodebug__))
-_mm_cvtsi128_si64(__m128i a)
+_mm_cvtsi128_si64(__m128i __a)
 {
-  return a[0];
+  return __a[0];
 }
 #endif
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_load_si128(__m128i const *p)
+_mm_load_si128(__m128i const *__p)
 {
-  return *p;
+  return *__p;
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_loadu_si128(__m128i const *p)
+_mm_loadu_si128(__m128i const *__p)
 {
   struct __loadu_si128 {
-    __m128i v;
+    __m128i __v;
   } __attribute__((packed, may_alias));
-  return ((struct __loadu_si128*)p)->v;
+  return ((struct __loadu_si128*)__p)->__v;
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_loadl_epi64(__m128i const *p)
+_mm_loadl_epi64(__m128i const *__p)
 {
   struct __mm_loadl_epi64_struct {
-    long long u;
+    long long __u;
   } __attribute__((__packed__, __may_alias__));
-  return (__m128i) { ((struct __mm_loadl_epi64_struct*)p)->u, 0};
+  return (__m128i) { ((struct __mm_loadl_epi64_struct*)__p)->__u, 0};
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
@@ -1106,33 +1106,33 @@ _mm_set_epi8(char b15, char b14, char b13, char b12, char b11, char b10, char b9
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_set1_epi64x(long long q)
+_mm_set1_epi64x(long long __q)
 {
-  return (__m128i){ q, q };
+  return (__m128i){ __q, __q };
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_set1_epi64(__m64 q)
+_mm_set1_epi64(__m64 __q)
 {
-  return (__m128i){ (long long)q, (long long)q };
+  return (__m128i){ (long long)__q, (long long)__q };
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_set1_epi32(int i)
+_mm_set1_epi32(int __i)
 {
-  return (__m128i)(__v4si){ i, i, i, i };
+  return (__m128i)(__v4si){ __i, __i, __i, __i };
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_set1_epi16(short w)
+_mm_set1_epi16(short __w)
 {
-  return (__m128i)(__v8hi){ w, w, w, w, w, w, w, w };
+  return (__m128i)(__v8hi){ __w, __w, __w, __w, __w, __w, __w, __w };
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_set1_epi8(char b)
+_mm_set1_epi8(char __b)
 {
-  return (__m128i)(__v16qi){ b, b, b, b, b, b, b, b, b, b, b, b, b, b, b, b };
+  return (__m128i)(__v16qi){ __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b };
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
@@ -1166,54 +1166,54 @@ _mm_setzero_si128(void)
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_store_si128(__m128i *p, __m128i b)
+_mm_store_si128(__m128i *__p, __m128i __b)
 {
-  *p = b;
+  *__p = __b;
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_storeu_si128(__m128i *p, __m128i b)
+_mm_storeu_si128(__m128i *__p, __m128i __b)
 {
-  __builtin_ia32_storedqu((char *)p, (__v16qi)b);
+  __builtin_ia32_storedqu((char *)__p, (__v16qi)__b);
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_maskmoveu_si128(__m128i d, __m128i n, char *p)
+_mm_maskmoveu_si128(__m128i __d, __m128i __n, char *__p)
 {
-  __builtin_ia32_maskmovdqu((__v16qi)d, (__v16qi)n, p);
+  __builtin_ia32_maskmovdqu((__v16qi)__d, (__v16qi)__n, __p);
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_storel_epi64(__m128i *p, __m128i a)
+_mm_storel_epi64(__m128i *__p, __m128i __a)
 {
   struct __mm_storel_epi64_struct {
-    long long u;
+    long long __u;
   } __attribute__((__packed__, __may_alias__));
-  ((struct __mm_storel_epi64_struct*)p)->u = a[0];
+  ((struct __mm_storel_epi64_struct*)__p)->__u = __a[0];
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_stream_pd(double *p, __m128d a)
+_mm_stream_pd(double *__p, __m128d __a)
 {
-  __builtin_ia32_movntpd(p, a);
+  __builtin_ia32_movntpd(__p, __a);
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_stream_si128(__m128i *p, __m128i a)
+_mm_stream_si128(__m128i *__p, __m128i __a)
 {
-  __builtin_ia32_movntdq(p, a);
+  __builtin_ia32_movntdq(__p, __a);
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_stream_si32(int *p, int a)
+_mm_stream_si32(int *__p, int __a)
 {
-  __builtin_ia32_movnti(p, a);
+  __builtin_ia32_movnti(__p, __a);
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_clflush(void const *p)
+_mm_clflush(void const *__p)
 {
-  __builtin_ia32_clflush(p);
+  __builtin_ia32_clflush(__p);
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
@@ -1229,42 +1229,42 @@ _mm_mfence(void)
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_packs_epi16(__m128i a, __m128i b)
+_mm_packs_epi16(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_packsswb128((__v8hi)a, (__v8hi)b);
+  return (__m128i)__builtin_ia32_packsswb128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_packs_epi32(__m128i a, __m128i b)
+_mm_packs_epi32(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_packssdw128((__v4si)a, (__v4si)b);
+  return (__m128i)__builtin_ia32_packssdw128((__v4si)__a, (__v4si)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_packus_epi16(__m128i a, __m128i b)
+_mm_packus_epi16(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_ia32_packuswb128((__v8hi)a, (__v8hi)b);
+  return (__m128i)__builtin_ia32_packuswb128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_extract_epi16(__m128i a, int imm)
+_mm_extract_epi16(__m128i __a, int __imm)
 {
-  __v8hi b = (__v8hi)a;
-  return (unsigned short)b[imm];
+  __v8hi __b = (__v8hi)__a;
+  return (unsigned short)__b[__imm];
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_insert_epi16(__m128i a, int b, int imm)
+_mm_insert_epi16(__m128i __a, int __b, int __imm)
 {
-  __v8hi c = (__v8hi)a;
-  c[imm & 7] = b;
-  return (__m128i)c;
+  __v8hi __c = (__v8hi)__a;
+  __c[__imm & 7] = __b;
+  return (__m128i)__c;
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_movemask_epi8(__m128i a)
+_mm_movemask_epi8(__m128i __a)
 {
-  return __builtin_ia32_pmovmskb128((__v16qi)a);
+  return __builtin_ia32_pmovmskb128((__v16qi)__a);
 }
 
 #define _mm_shuffle_epi32(a, imm) __extension__ ({ \
@@ -1290,87 +1290,87 @@ _mm_movemask_epi8(__m128i a)
                                    4 + (((imm) & 0xc0) >> 6)); })
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_unpackhi_epi8(__m128i a, __m128i b)
+_mm_unpackhi_epi8(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_shufflevector((__v16qi)a, (__v16qi)b, 8, 16+8, 9, 16+9, 10, 16+10, 11, 16+11, 12, 16+12, 13, 16+13, 14, 16+14, 15, 16+15);
+  return (__m128i)__builtin_shufflevector((__v16qi)__a, (__v16qi)__b, 8, 16+8, 9, 16+9, 10, 16+10, 11, 16+11, 12, 16+12, 13, 16+13, 14, 16+14, 15, 16+15);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_unpackhi_epi16(__m128i a, __m128i b)
+_mm_unpackhi_epi16(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_shufflevector((__v8hi)a, (__v8hi)b, 4, 8+4, 5, 8+5, 6, 8+6, 7, 8+7);
+  return (__m128i)__builtin_shufflevector((__v8hi)__a, (__v8hi)__b, 4, 8+4, 5, 8+5, 6, 8+6, 7, 8+7);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_unpackhi_epi32(__m128i a, __m128i b)
+_mm_unpackhi_epi32(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_shufflevector((__v4si)a, (__v4si)b, 2, 4+2, 3, 4+3);
+  return (__m128i)__builtin_shufflevector((__v4si)__a, (__v4si)__b, 2, 4+2, 3, 4+3);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_unpackhi_epi64(__m128i a, __m128i b)
+_mm_unpackhi_epi64(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_shufflevector(a, b, 1, 2+1);
+  return (__m128i)__builtin_shufflevector(__a, __b, 1, 2+1);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_unpacklo_epi8(__m128i a, __m128i b)
+_mm_unpacklo_epi8(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_shufflevector((__v16qi)a, (__v16qi)b, 0, 16+0, 1, 16+1, 2, 16+2, 3, 16+3, 4, 16+4, 5, 16+5, 6, 16+6, 7, 16+7);
+  return (__m128i)__builtin_shufflevector((__v16qi)__a, (__v16qi)__b, 0, 16+0, 1, 16+1, 2, 16+2, 3, 16+3, 4, 16+4, 5, 16+5, 6, 16+6, 7, 16+7);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_unpacklo_epi16(__m128i a, __m128i b)
+_mm_unpacklo_epi16(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_shufflevector((__v8hi)a, (__v8hi)b, 0, 8+0, 1, 8+1, 2, 8+2, 3, 8+3);
+  return (__m128i)__builtin_shufflevector((__v8hi)__a, (__v8hi)__b, 0, 8+0, 1, 8+1, 2, 8+2, 3, 8+3);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_unpacklo_epi32(__m128i a, __m128i b)
+_mm_unpacklo_epi32(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_shufflevector((__v4si)a, (__v4si)b, 0, 4+0, 1, 4+1);
+  return (__m128i)__builtin_shufflevector((__v4si)__a, (__v4si)__b, 0, 4+0, 1, 4+1);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_unpacklo_epi64(__m128i a, __m128i b)
+_mm_unpacklo_epi64(__m128i __a, __m128i __b)
 {
-  return (__m128i)__builtin_shufflevector(a, b, 0, 2+0);
+  return (__m128i)__builtin_shufflevector(__a, __b, 0, 2+0);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_movepi64_pi64(__m128i a)
+_mm_movepi64_pi64(__m128i __a)
 {
-  return (__m64)a[0];
+  return (__m64)__a[0];
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_movpi64_pi64(__m64 a)
+_mm_movpi64_pi64(__m64 __a)
 {
-  return (__m128i){ (long long)a, 0 };
+  return (__m128i){ (long long)__a, 0 };
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_move_epi64(__m128i a)
+_mm_move_epi64(__m128i __a)
 {
-  return __builtin_shufflevector(a, (__m128i){ 0 }, 0, 2);
+  return __builtin_shufflevector(__a, (__m128i){ 0 }, 0, 2);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_unpackhi_pd(__m128d a, __m128d b)
+_mm_unpackhi_pd(__m128d __a, __m128d __b)
 {
-  return __builtin_shufflevector(a, b, 1, 2+1);
+  return __builtin_shufflevector(__a, __b, 1, 2+1);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_unpacklo_pd(__m128d a, __m128d b)
+_mm_unpacklo_pd(__m128d __a, __m128d __b)
 {
-  return __builtin_shufflevector(a, b, 0, 2+0);
+  return __builtin_shufflevector(__a, __b, 0, 2+0);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_movemask_pd(__m128d a)
+_mm_movemask_pd(__m128d __a)
 {
-  return __builtin_ia32_movmskpd(a);
+  return __builtin_ia32_movmskpd(__a);
 }
 
 #define _mm_shuffle_pd(a, b, i) __extension__ ({ \
@@ -1379,39 +1379,39 @@ _mm_movemask_pd(__m128d a)
   __builtin_shufflevector(__a, __b, (i) & 1, (((i) & 2) >> 1) + 2); })
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_castpd_ps(__m128d in)
+_mm_castpd_ps(__m128d __in)
 {
-  return (__m128)in;
+  return (__m128)__in;
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_castpd_si128(__m128d in)
+_mm_castpd_si128(__m128d __in)
 {
-  return (__m128i)in;
+  return (__m128i)__in;
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_castps_pd(__m128 in)
+_mm_castps_pd(__m128 __in)
 {
-  return (__m128d)in;
+  return (__m128d)__in;
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_castps_si128(__m128 in)
+_mm_castps_si128(__m128 __in)
 {
-  return (__m128i)in;
+  return (__m128i)__in;
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_castsi128_ps(__m128i in)
+_mm_castsi128_ps(__m128i __in)
 {
-  return (__m128)in;
+  return (__m128)__in;
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_castsi128_pd(__m128i in)
+_mm_castsi128_pd(__m128i __in)
 {
-  return (__m128d)in;
+  return (__m128d)__in;
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))