diff --git a/renderscript/clang-include/CMakeLists.txt b/renderscript/clang-include/CMakeLists.txt
deleted file mode 100644
index 6e9cc68..0000000
--- a/renderscript/clang-include/CMakeLists.txt
+++ /dev/null
@@ -1,93 +0,0 @@
-set(files
-  altivec.h
-  ammintrin.h
-  avxintrin.h
-  avx2intrin.h
-  bmiintrin.h
-  bmi2intrin.h
-  emmintrin.h
-  float.h
-  fma4intrin.h
-  fmaintrin.h
-  immintrin.h
-  iso646.h
-  limits.h
-  lzcntintrin.h
-  mm3dnow.h
-  mmintrin.h
-  mm_malloc.h
-  nmmintrin.h
-  pmmintrin.h
-  popcntintrin.h
-  smmintrin.h
-  stdalign.h
-  stdarg.h
-  stdbool.h
-  stddef.h
-  stdint.h
-  tgmath.h
-  tmmintrin.h
-  varargs.h
-  wmmintrin.h
-  x86intrin.h
-  xmmintrin.h
-  xopintrin.h
-  cpuid.h
-  unwind.h
-  module.map
-  )
-
-set(output_dir ${LLVM_BINARY_DIR}/lib/clang/${CLANG_VERSION}/include)
-
-# If we are in an IDE that has a configuration directory, we need to
-# create a second copy of the headers so that 'clang' can find them if
-# it's run from the build directory.
-if(MSVC_IDE OR XCODE)
-   set(other_output_dir ${LLVM_BINARY_DIR}/bin/lib/clang/${CLANG_VERSION}/include)
-endif()
-
-# Generate arm_neon.h
-clang_tablegen(arm_neon.h.inc -gen-arm-neon
-  SOURCE ${CLANG_SOURCE_DIR}/include/clang/Basic/arm_neon.td)
-
-set(out_files)
-foreach( f ${files} )
-  set( src ${CMAKE_CURRENT_SOURCE_DIR}/${f} )
-  set( dst ${output_dir}/${f} )
-  add_custom_command(OUTPUT ${dst}
-    DEPENDS ${src}
-    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst}
-    COMMENT "Copying clang's ${f}...")
-  list(APPEND out_files ${dst})
-
-  if(other_output_dir)
-   set(other_dst ${other_output_dir}/${f})
-    add_custom_command(OUTPUT ${other_dst}
-      DEPENDS ${src}
-      COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${other_dst}
-      COMMENT "Copying clang's ${f}...")    
-    list(APPEND out_files ${other_dst})
-  endif()
-endforeach( f )
-
-add_custom_command(OUTPUT ${output_dir}/arm_neon.h 
-  DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/arm_neon.h.inc
-  COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_BINARY_DIR}/arm_neon.h.inc ${output_dir}/arm_neon.h
-  COMMENT "Copying clang's arm_neon.h...")
-list(APPEND out_files ${output_dir}/arm_neon.h)
-
-if (other_output_dir)
-    set(other_dst ${other_output_dir}/arm_neon.h)
-    add_custom_command(OUTPUT ${other_dst}
-      DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/arm_neon.h.inc
-      COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_BINARY_DIR}/arm_neon.h.inc ${other_dst}
-      COMMENT "Copying clang's arm_neon.h...")
-    list(APPEND out_files ${other_dst})
-endif ()
-
-add_custom_target(clang-headers ALL DEPENDS ${out_files})
-set_target_properties(clang-headers PROPERTIES FOLDER "Misc")
-
-install(FILES ${files} ${output_dir}/arm_neon.h
-  PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
-  DESTINATION lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION}/include)
diff --git a/renderscript/clang-include/__wmmintrin_aes.h b/renderscript/clang-include/__wmmintrin_aes.h
new file mode 100644
index 0000000..2bfa027
--- /dev/null
+++ b/renderscript/clang-include/__wmmintrin_aes.h
@@ -0,0 +1,67 @@
+/*===---- __wmmintrin_aes.h - AES intrinsics -------------------------------===
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef _WMMINTRIN_AES_H
+#define _WMMINTRIN_AES_H
+
+#include <emmintrin.h>
+
+#if !defined (__AES__)
+#  error "AES instructions not enabled"
+#else
+
+static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
+_mm_aesenc_si128(__m128i __V, __m128i __R)
+{
+  return (__m128i)__builtin_ia32_aesenc128(__V, __R);
+}
+
+static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
+_mm_aesenclast_si128(__m128i __V, __m128i __R)
+{
+  return (__m128i)__builtin_ia32_aesenclast128(__V, __R);
+}
+
+static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
+_mm_aesdec_si128(__m128i __V, __m128i __R)
+{
+  return (__m128i)__builtin_ia32_aesdec128(__V, __R);
+}
+
+static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
+_mm_aesdeclast_si128(__m128i __V, __m128i __R)
+{
+  return (__m128i)__builtin_ia32_aesdeclast128(__V, __R);
+}
+
+static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
+_mm_aesimc_si128(__m128i __V)
+{
+  return (__m128i)__builtin_ia32_aesimc128(__V);
+}
+
+#define _mm_aeskeygenassist_si128(C, R) \
+  __builtin_ia32_aeskeygenassist128((C), (R))
+
+#endif
+
+#endif  /* _WMMINTRIN_AES_H */
diff --git a/renderscript/clang-include/__wmmintrin_pclmul.h b/renderscript/clang-include/__wmmintrin_pclmul.h
new file mode 100644
index 0000000..8d1f1b7
--- /dev/null
+++ b/renderscript/clang-include/__wmmintrin_pclmul.h
@@ -0,0 +1,34 @@
+/*===---- __wmmintrin_pclmul.h - AES intrinsics ----------------------------===
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef _WMMINTRIN_PCLMUL_H
+#define _WMMINTRIN_PCLMUL_H
+
+#if !defined (__PCLMUL__)
+# error "PCLMUL instruction is not enabled"
+#else
+#define _mm_clmulepi64_si128(__X, __Y, __I) \
+  ((__m128i)__builtin_ia32_pclmulqdq128((__v2di)(__m128i)(__X), \
+                                        (__v2di)(__m128i)(__Y), (char)(__I)))
+#endif
+
+#endif /* _WMMINTRIN_PCLMUL_H */
diff --git a/renderscript/clang-include/altivec.h b/renderscript/clang-include/altivec.h
index a225378..74ce08a 100644
--- a/renderscript/clang-include/altivec.h
+++ b/renderscript/clang-include/altivec.h
@@ -37,41 +37,41 @@
 #define __ATTRS_o_ai __attribute__((__overloadable__, __always_inline__))
 
 static vector signed char __ATTRS_o_ai
-vec_perm(vector signed char a, vector signed char b, vector unsigned char c);
+vec_perm(vector signed char __a, vector signed char __b, vector unsigned char __c);
 
 static vector unsigned char __ATTRS_o_ai
-vec_perm(vector unsigned char a,
-         vector unsigned char b, 
-         vector unsigned char c);
+vec_perm(vector unsigned char __a,
+         vector unsigned char __b,
+         vector unsigned char __c);
 
 static vector bool char __ATTRS_o_ai
-vec_perm(vector bool char a, vector bool char b, vector unsigned char c);
+vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c);
 
 static vector short __ATTRS_o_ai
-vec_perm(vector short a, vector short b, vector unsigned char c);
+vec_perm(vector short __a, vector short __b, vector unsigned char __c);
 
 static vector unsigned short __ATTRS_o_ai
-vec_perm(vector unsigned short a,
-         vector unsigned short b, 
-         vector unsigned char c);
+vec_perm(vector unsigned short __a,
+         vector unsigned short __b,
+         vector unsigned char __c);
 
 static vector bool short __ATTRS_o_ai
-vec_perm(vector bool short a, vector bool short b, vector unsigned char c);
+vec_perm(vector bool short __a, vector bool short __b, vector unsigned char __c);
 
 static vector pixel __ATTRS_o_ai
-vec_perm(vector pixel a, vector pixel b, vector unsigned char c);
+vec_perm(vector pixel __a, vector pixel __b, vector unsigned char __c);
 
 static vector int __ATTRS_o_ai
-vec_perm(vector int a, vector int b, vector unsigned char c);
+vec_perm(vector int __a, vector int __b, vector unsigned char __c);
 
 static vector unsigned int __ATTRS_o_ai
-vec_perm(vector unsigned int a, vector unsigned int b, vector unsigned char c);
+vec_perm(vector unsigned int __a, vector unsigned int __b, vector unsigned char __c);
 
 static vector bool int __ATTRS_o_ai
-vec_perm(vector bool int a, vector bool int b, vector unsigned char c);
+vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c);
 
 static vector float __ATTRS_o_ai
-vec_perm(vector float a, vector float b, vector unsigned char c);
+vec_perm(vector float __a, vector float __b, vector unsigned char __c);
 
 /* vec_abs */
 
@@ -80,29 +80,29 @@
 #define __builtin_altivec_abs_v4si  vec_abs
 
 static vector signed char __ATTRS_o_ai
-vec_abs(vector signed char a)
+vec_abs(vector signed char __a)
 {
-  return __builtin_altivec_vmaxsb(a, -a);
+  return __builtin_altivec_vmaxsb(__a, -__a);
 }
 
 static vector signed short __ATTRS_o_ai
-vec_abs(vector signed short a)
+vec_abs(vector signed short __a)
 {
-  return __builtin_altivec_vmaxsh(a, -a);
+  return __builtin_altivec_vmaxsh(__a, -__a);
 }
 
 static vector signed int __ATTRS_o_ai
-vec_abs(vector signed int a)
+vec_abs(vector signed int __a)
 {
-  return __builtin_altivec_vmaxsw(a, -a);
+  return __builtin_altivec_vmaxsw(__a, -__a);
 }
 
 static vector float __ATTRS_o_ai
-vec_abs(vector float a)
+vec_abs(vector float __a)
 {
-  vector unsigned int res = (vector unsigned int)a 
+  vector unsigned int __res = (vector unsigned int)__a
                             & (vector unsigned int)(0x7FFFFFFF);
-  return (vector float)res;
+  return (vector float)__res;
 }
 
 /* vec_abss */
@@ -112,140 +112,140 @@
 #define __builtin_altivec_abss_v4si  vec_abss
 
 static vector signed char __ATTRS_o_ai
-vec_abss(vector signed char a)
+vec_abss(vector signed char __a)
 {
   return __builtin_altivec_vmaxsb
-           (a, __builtin_altivec_vsubsbs((vector signed char)(0), a));
+           (__a, __builtin_altivec_vsubsbs((vector signed char)(0), __a));
 }
 
 static vector signed short __ATTRS_o_ai
-vec_abss(vector signed short a)
+vec_abss(vector signed short __a)
 {
   return __builtin_altivec_vmaxsh
-           (a, __builtin_altivec_vsubshs((vector signed short)(0), a));
+           (__a, __builtin_altivec_vsubshs((vector signed short)(0), __a));
 }
 
 static vector signed int __ATTRS_o_ai
-vec_abss(vector signed int a)
+vec_abss(vector signed int __a)
 {
   return __builtin_altivec_vmaxsw
-           (a, __builtin_altivec_vsubsws((vector signed int)(0), a));
+           (__a, __builtin_altivec_vsubsws((vector signed int)(0), __a));
 }
 
 /* vec_add */
 
 static vector signed char __ATTRS_o_ai
-vec_add(vector signed char a, vector signed char b)
+vec_add(vector signed char __a, vector signed char __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_add(vector bool char a, vector signed char b)
+vec_add(vector bool char __a, vector signed char __b)
 {
-  return (vector signed char)a + b;
+  return (vector signed char)__a + __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_add(vector signed char a, vector bool char b)
+vec_add(vector signed char __a, vector bool char __b)
 {
-  return a + (vector signed char)b;
+  return __a + (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_add(vector unsigned char a, vector unsigned char b)
+vec_add(vector unsigned char __a, vector unsigned char __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_add(vector bool char a, vector unsigned char b)
+vec_add(vector bool char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)a + b;
+  return (vector unsigned char)__a + __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_add(vector unsigned char a, vector bool char b)
+vec_add(vector unsigned char __a, vector bool char __b)
 {
-  return a + (vector unsigned char)b;
+  return __a + (vector unsigned char)__b;
 }
 
 static vector short __ATTRS_o_ai
-vec_add(vector short a, vector short b)
+vec_add(vector short __a, vector short __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_add(vector bool short a, vector short b)
+vec_add(vector bool short __a, vector short __b)
 {
-  return (vector short)a + b;
+  return (vector short)__a + __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_add(vector short a, vector bool short b)
+vec_add(vector short __a, vector bool short __b)
 {
-  return a + (vector short)b;
+  return __a + (vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_add(vector unsigned short a, vector unsigned short b)
+vec_add(vector unsigned short __a, vector unsigned short __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_add(vector bool short a, vector unsigned short b)
+vec_add(vector bool short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)a + b;
+  return (vector unsigned short)__a + __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_add(vector unsigned short a, vector bool short b)
+vec_add(vector unsigned short __a, vector bool short __b)
 {
-  return a + (vector unsigned short)b;
+  return __a + (vector unsigned short)__b;
 }
 
 static vector int __ATTRS_o_ai
-vec_add(vector int a, vector int b)
+vec_add(vector int __a, vector int __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_add(vector bool int a, vector int b)
+vec_add(vector bool int __a, vector int __b)
 {
-  return (vector int)a + b;
+  return (vector int)__a + __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_add(vector int a, vector bool int b)
+vec_add(vector int __a, vector bool int __b)
 {
-  return a + (vector int)b;
+  return __a + (vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_add(vector unsigned int a, vector unsigned int b)
+vec_add(vector unsigned int __a, vector unsigned int __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_add(vector bool int a, vector unsigned int b)
+vec_add(vector bool int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)a + b;
+  return (vector unsigned int)__a + __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_add(vector unsigned int a, vector bool int b)
+vec_add(vector unsigned int __a, vector bool int __b)
 {
-  return a + (vector unsigned int)b;
+  return __a + (vector unsigned int)__b;
 }
 
 static vector float __ATTRS_o_ai
-vec_add(vector float a, vector float b)
+vec_add(vector float __a, vector float __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 /* vec_vaddubm */
@@ -253,39 +253,39 @@
 #define __builtin_altivec_vaddubm vec_vaddubm
 
 static vector signed char __ATTRS_o_ai
-vec_vaddubm(vector signed char a, vector signed char b)
+vec_vaddubm(vector signed char __a, vector signed char __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vaddubm(vector bool char a, vector signed char b)
+vec_vaddubm(vector bool char __a, vector signed char __b)
 {
-  return (vector signed char)a + b;
+  return (vector signed char)__a + __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vaddubm(vector signed char a, vector bool char b)
+vec_vaddubm(vector signed char __a, vector bool char __b)
 {
-  return a + (vector signed char)b;
+  return __a + (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vaddubm(vector unsigned char a, vector unsigned char b)
+vec_vaddubm(vector unsigned char __a, vector unsigned char __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vaddubm(vector bool char a, vector unsigned char b)
+vec_vaddubm(vector bool char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)a + b;
+  return (vector unsigned char)__a + __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vaddubm(vector unsigned char a, vector bool char b)
+vec_vaddubm(vector unsigned char __a, vector bool char __b)
 {
-  return a + (vector unsigned char)b;
+  return __a + (vector unsigned char)__b;
 }
 
 /* vec_vadduhm */
@@ -293,39 +293,39 @@
 #define __builtin_altivec_vadduhm vec_vadduhm
 
 static vector short __ATTRS_o_ai
-vec_vadduhm(vector short a, vector short b)
+vec_vadduhm(vector short __a, vector short __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vadduhm(vector bool short a, vector short b)
+vec_vadduhm(vector bool short __a, vector short __b)
 {
-  return (vector short)a + b;
+  return (vector short)__a + __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vadduhm(vector short a, vector bool short b)
+vec_vadduhm(vector short __a, vector bool short __b)
 {
-  return a + (vector short)b;
+  return __a + (vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vadduhm(vector unsigned short a, vector unsigned short b)
+vec_vadduhm(vector unsigned short __a, vector unsigned short __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vadduhm(vector bool short a, vector unsigned short b)
+vec_vadduhm(vector bool short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)a + b;
+  return (vector unsigned short)__a + __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vadduhm(vector unsigned short a, vector bool short b)
+vec_vadduhm(vector unsigned short __a, vector bool short __b)
 {
-  return a + (vector unsigned short)b;
+  return __a + (vector unsigned short)__b;
 }
 
 /* vec_vadduwm */
@@ -333,39 +333,39 @@
 #define __builtin_altivec_vadduwm vec_vadduwm
 
 static vector int __ATTRS_o_ai
-vec_vadduwm(vector int a, vector int b)
+vec_vadduwm(vector int __a, vector int __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vadduwm(vector bool int a, vector int b)
+vec_vadduwm(vector bool int __a, vector int __b)
 {
-  return (vector int)a + b;
+  return (vector int)__a + __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vadduwm(vector int a, vector bool int b)
+vec_vadduwm(vector int __a, vector bool int __b)
 {
-  return a + (vector int)b;
+  return __a + (vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vadduwm(vector unsigned int a, vector unsigned int b)
+vec_vadduwm(vector unsigned int __a, vector unsigned int __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vadduwm(vector bool int a, vector unsigned int b)
+vec_vadduwm(vector bool int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)a + b;
+  return (vector unsigned int)__a + __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vadduwm(vector unsigned int a, vector bool int b)
+vec_vadduwm(vector unsigned int __a, vector bool int __b)
 {
-  return a + (vector unsigned int)b;
+  return __a + (vector unsigned int)__b;
 }
 
 /* vec_vaddfp */
@@ -373,255 +373,255 @@
 #define __builtin_altivec_vaddfp  vec_vaddfp
 
 static vector float __attribute__((__always_inline__))
-vec_vaddfp(vector float a, vector float b)
+vec_vaddfp(vector float __a, vector float __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 /* vec_addc */
 
 static vector unsigned int __attribute__((__always_inline__))
-vec_addc(vector unsigned int a, vector unsigned int b)
+vec_addc(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vaddcuw(a, b);
+  return __builtin_altivec_vaddcuw(__a, __b);
 }
 
 /* vec_vaddcuw */
 
 static vector unsigned int __attribute__((__always_inline__))
-vec_vaddcuw(vector unsigned int a, vector unsigned int b)
+vec_vaddcuw(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vaddcuw(a, b);
+  return __builtin_altivec_vaddcuw(__a, __b);
 }
 
 /* vec_adds */
 
 static vector signed char __ATTRS_o_ai
-vec_adds(vector signed char a, vector signed char b)
+vec_adds(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vaddsbs(a, b);
+  return __builtin_altivec_vaddsbs(__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_adds(vector bool char a, vector signed char b)
+vec_adds(vector bool char __a, vector signed char __b)
 {
-  return __builtin_altivec_vaddsbs((vector signed char)a, b);
+  return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_adds(vector signed char a, vector bool char b)
+vec_adds(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vaddsbs(a, (vector signed char)b);
+  return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_adds(vector unsigned char a, vector unsigned char b)
+vec_adds(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vaddubs(a, b);
+  return __builtin_altivec_vaddubs(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_adds(vector bool char a, vector unsigned char b)
+vec_adds(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vaddubs((vector unsigned char)a, b);
+  return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_adds(vector unsigned char a, vector bool char b)
+vec_adds(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vaddubs(a, (vector unsigned char)b);
+  return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_adds(vector short a, vector short b)
+vec_adds(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vaddshs(a, b);
+  return __builtin_altivec_vaddshs(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_adds(vector bool short a, vector short b)
+vec_adds(vector bool short __a, vector short __b)
 {
-  return __builtin_altivec_vaddshs((vector short)a, b);
+  return __builtin_altivec_vaddshs((vector short)__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_adds(vector short a, vector bool short b)
+vec_adds(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vaddshs(a, (vector short)b);
+  return __builtin_altivec_vaddshs(__a, (vector short)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_adds(vector unsigned short a, vector unsigned short b)
+vec_adds(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vadduhs(a, b);
+  return __builtin_altivec_vadduhs(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_adds(vector bool short a, vector unsigned short b)
+vec_adds(vector bool short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vadduhs((vector unsigned short)a, b);
+  return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_adds(vector unsigned short a, vector bool short b)
+vec_adds(vector unsigned short __a, vector bool short __b)
 {
-  return __builtin_altivec_vadduhs(a, (vector unsigned short)b);
+  return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_adds(vector int a, vector int b)
+vec_adds(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vaddsws(a, b);
+  return __builtin_altivec_vaddsws(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_adds(vector bool int a, vector int b)
+vec_adds(vector bool int __a, vector int __b)
 {
-  return __builtin_altivec_vaddsws((vector int)a, b);
+  return __builtin_altivec_vaddsws((vector int)__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_adds(vector int a, vector bool int b)
+vec_adds(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vaddsws(a, (vector int)b);
+  return __builtin_altivec_vaddsws(__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_adds(vector unsigned int a, vector unsigned int b)
+vec_adds(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vadduws(a, b);
+  return __builtin_altivec_vadduws(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_adds(vector bool int a, vector unsigned int b)
+vec_adds(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vadduws((vector unsigned int)a, b);
+  return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_adds(vector unsigned int a, vector bool int b)
+vec_adds(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vadduws(a, (vector unsigned int)b);
+  return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
 }
 
 /* vec_vaddsbs */
 
 static vector signed char __ATTRS_o_ai
-vec_vaddsbs(vector signed char a, vector signed char b)
+vec_vaddsbs(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vaddsbs(a, b);
+  return __builtin_altivec_vaddsbs(__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vaddsbs(vector bool char a, vector signed char b)
+vec_vaddsbs(vector bool char __a, vector signed char __b)
 {
-  return __builtin_altivec_vaddsbs((vector signed char)a, b);
+  return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vaddsbs(vector signed char a, vector bool char b)
+vec_vaddsbs(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vaddsbs(a, (vector signed char)b);
+  return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
 }
 
 /* vec_vaddubs */
 
 static vector unsigned char __ATTRS_o_ai
-vec_vaddubs(vector unsigned char a, vector unsigned char b)
+vec_vaddubs(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vaddubs(a, b);
+  return __builtin_altivec_vaddubs(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vaddubs(vector bool char a, vector unsigned char b)
+vec_vaddubs(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vaddubs((vector unsigned char)a, b);
+  return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vaddubs(vector unsigned char a, vector bool char b)
+vec_vaddubs(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vaddubs(a, (vector unsigned char)b);
+  return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
 }
 
 /* vec_vaddshs */
 
 static vector short __ATTRS_o_ai
-vec_vaddshs(vector short a, vector short b)
+vec_vaddshs(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vaddshs(a, b);
+  return __builtin_altivec_vaddshs(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vaddshs(vector bool short a, vector short b)
+vec_vaddshs(vector bool short __a, vector short __b)
 {
-  return __builtin_altivec_vaddshs((vector short)a, b);
+  return __builtin_altivec_vaddshs((vector short)__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vaddshs(vector short a, vector bool short b)
+vec_vaddshs(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vaddshs(a, (vector short)b);
+  return __builtin_altivec_vaddshs(__a, (vector short)__b);
 }
 
 /* vec_vadduhs */
 
 static vector unsigned short __ATTRS_o_ai
-vec_vadduhs(vector unsigned short a, vector unsigned short b)
+vec_vadduhs(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vadduhs(a, b);
+  return __builtin_altivec_vadduhs(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vadduhs(vector bool short a, vector unsigned short b)
+vec_vadduhs(vector bool short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vadduhs((vector unsigned short)a, b);
+  return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vadduhs(vector unsigned short a, vector bool short b)
+vec_vadduhs(vector unsigned short __a, vector bool short __b)
 {
-  return __builtin_altivec_vadduhs(a, (vector unsigned short)b);
+  return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
 }
 
 /* vec_vaddsws */
 
 static vector int __ATTRS_o_ai
-vec_vaddsws(vector int a, vector int b)
+vec_vaddsws(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vaddsws(a, b);
+  return __builtin_altivec_vaddsws(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vaddsws(vector bool int a, vector int b)
+vec_vaddsws(vector bool int __a, vector int __b)
 {
-  return __builtin_altivec_vaddsws((vector int)a, b);
+  return __builtin_altivec_vaddsws((vector int)__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vaddsws(vector int a, vector bool int b)
+vec_vaddsws(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vaddsws(a, (vector int)b);
+  return __builtin_altivec_vaddsws(__a, (vector int)__b);
 }
 
 /* vec_vadduws */
 
 static vector unsigned int __ATTRS_o_ai
-vec_vadduws(vector unsigned int a, vector unsigned int b)
+vec_vadduws(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vadduws(a, b);
+  return __builtin_altivec_vadduws(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vadduws(vector bool int a, vector unsigned int b)
+vec_vadduws(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vadduws((vector unsigned int)a, b);
+  return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vadduws(vector unsigned int a, vector bool int b)
+vec_vadduws(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vadduws(a, (vector unsigned int)b);
+  return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
 }
 
 /* vec_and */
@@ -629,299 +629,299 @@
 #define __builtin_altivec_vand vec_and
 
 static vector signed char __ATTRS_o_ai
-vec_and(vector signed char a, vector signed char b)
+vec_and(vector signed char __a, vector signed char __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_and(vector bool char a, vector signed char b)
+vec_and(vector bool char __a, vector signed char __b)
 {
-  return (vector signed char)a & b;
+  return (vector signed char)__a & __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_and(vector signed char a, vector bool char b)
+vec_and(vector signed char __a, vector bool char __b)
 {
-  return a & (vector signed char)b;
+  return __a & (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_and(vector unsigned char a, vector unsigned char b)
+vec_and(vector unsigned char __a, vector unsigned char __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_and(vector bool char a, vector unsigned char b)
+vec_and(vector bool char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)a & b;
+  return (vector unsigned char)__a & __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_and(vector unsigned char a, vector bool char b)
+vec_and(vector unsigned char __a, vector bool char __b)
 {
-  return a & (vector unsigned char)b;
+  return __a & (vector unsigned char)__b;
 }
 
 static vector bool char __ATTRS_o_ai
-vec_and(vector bool char a, vector bool char b)
+vec_and(vector bool char __a, vector bool char __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_and(vector short a, vector short b)
+vec_and(vector short __a, vector short __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_and(vector bool short a, vector short b)
+vec_and(vector bool short __a, vector short __b)
 {
-  return (vector short)a & b;
+  return (vector short)__a & __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_and(vector short a, vector bool short b)
+vec_and(vector short __a, vector bool short __b)
 {
-  return a & (vector short)b;
+  return __a & (vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_and(vector unsigned short a, vector unsigned short b)
+vec_and(vector unsigned short __a, vector unsigned short __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_and(vector bool short a, vector unsigned short b)
+vec_and(vector bool short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)a & b;
+  return (vector unsigned short)__a & __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_and(vector unsigned short a, vector bool short b)
+vec_and(vector unsigned short __a, vector bool short __b)
 {
-  return a & (vector unsigned short)b;
+  return __a & (vector unsigned short)__b;
 }
 
 static vector bool short __ATTRS_o_ai
-vec_and(vector bool short a, vector bool short b)
+vec_and(vector bool short __a, vector bool short __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_and(vector int a, vector int b)
+vec_and(vector int __a, vector int __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_and(vector bool int a, vector int b)
+vec_and(vector bool int __a, vector int __b)
 {
-  return (vector int)a & b;
+  return (vector int)__a & __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_and(vector int a, vector bool int b)
+vec_and(vector int __a, vector bool int __b)
 {
-  return a & (vector int)b;
+  return __a & (vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_and(vector unsigned int a, vector unsigned int b)
+vec_and(vector unsigned int __a, vector unsigned int __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_and(vector bool int a, vector unsigned int b)
+vec_and(vector bool int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)a & b;
+  return (vector unsigned int)__a & __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_and(vector unsigned int a, vector bool int b)
+vec_and(vector unsigned int __a, vector bool int __b)
 {
-  return a & (vector unsigned int)b;
+  return __a & (vector unsigned int)__b;
 }
 
 static vector bool int __ATTRS_o_ai
-vec_and(vector bool int a, vector bool int b)
+vec_and(vector bool int __a, vector bool int __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector float __ATTRS_o_ai
-vec_and(vector float a, vector float b)
+vec_and(vector float __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a & (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a & (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_and(vector bool int a, vector float b)
+vec_and(vector bool int __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a & (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a & (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_and(vector float a, vector bool int b)
+vec_and(vector float __a, vector bool int __b)
 {
-  vector unsigned int res = (vector unsigned int)a & (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a & (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 /* vec_vand */
 
 static vector signed char __ATTRS_o_ai
-vec_vand(vector signed char a, vector signed char b)
+vec_vand(vector signed char __a, vector signed char __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vand(vector bool char a, vector signed char b)
+vec_vand(vector bool char __a, vector signed char __b)
 {
-  return (vector signed char)a & b;
+  return (vector signed char)__a & __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vand(vector signed char a, vector bool char b)
+vec_vand(vector signed char __a, vector bool char __b)
 {
-  return a & (vector signed char)b;
+  return __a & (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vand(vector unsigned char a, vector unsigned char b)
+vec_vand(vector unsigned char __a, vector unsigned char __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vand(vector bool char a, vector unsigned char b)
+vec_vand(vector bool char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)a & b;
+  return (vector unsigned char)__a & __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vand(vector unsigned char a, vector bool char b)
+vec_vand(vector unsigned char __a, vector bool char __b)
 {
-  return a & (vector unsigned char)b;
+  return __a & (vector unsigned char)__b;
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vand(vector bool char a, vector bool char b)
+vec_vand(vector bool char __a, vector bool char __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vand(vector short a, vector short b)
+vec_vand(vector short __a, vector short __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vand(vector bool short a, vector short b)
+vec_vand(vector bool short __a, vector short __b)
 {
-  return (vector short)a & b;
+  return (vector short)__a & __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vand(vector short a, vector bool short b)
+vec_vand(vector short __a, vector bool short __b)
 {
-  return a & (vector short)b;
+  return __a & (vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vand(vector unsigned short a, vector unsigned short b)
+vec_vand(vector unsigned short __a, vector unsigned short __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vand(vector bool short a, vector unsigned short b)
+vec_vand(vector bool short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)a & b;
+  return (vector unsigned short)__a & __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vand(vector unsigned short a, vector bool short b)
+vec_vand(vector unsigned short __a, vector bool short __b)
 {
-  return a & (vector unsigned short)b;
+  return __a & (vector unsigned short)__b;
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vand(vector bool short a, vector bool short b)
+vec_vand(vector bool short __a, vector bool short __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vand(vector int a, vector int b)
+vec_vand(vector int __a, vector int __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vand(vector bool int a, vector int b)
+vec_vand(vector bool int __a, vector int __b)
 {
-  return (vector int)a & b;
+  return (vector int)__a & __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vand(vector int a, vector bool int b)
+vec_vand(vector int __a, vector bool int __b)
 {
-  return a & (vector int)b;
+  return __a & (vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vand(vector unsigned int a, vector unsigned int b)
+vec_vand(vector unsigned int __a, vector unsigned int __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vand(vector bool int a, vector unsigned int b)
+vec_vand(vector bool int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)a & b;
+  return (vector unsigned int)__a & __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vand(vector unsigned int a, vector bool int b)
+vec_vand(vector unsigned int __a, vector bool int __b)
 {
-  return a & (vector unsigned int)b;
+  return __a & (vector unsigned int)__b;
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vand(vector bool int a, vector bool int b)
+vec_vand(vector bool int __a, vector bool int __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector float __ATTRS_o_ai
-vec_vand(vector float a, vector float b)
+vec_vand(vector float __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a & (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a & (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_vand(vector bool int a, vector float b)
+vec_vand(vector bool int __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a & (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a & (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_vand(vector float a, vector bool int b)
+vec_vand(vector float __a, vector bool int __b)
 {
-  vector unsigned int res = (vector unsigned int)a & (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a & (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 /* vec_andc */
@@ -929,703 +929,703 @@
 #define __builtin_altivec_vandc vec_andc
 
 static vector signed char __ATTRS_o_ai
-vec_andc(vector signed char a, vector signed char b)
+vec_andc(vector signed char __a, vector signed char __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_andc(vector bool char a, vector signed char b)
+vec_andc(vector bool char __a, vector signed char __b)
 {
-  return (vector signed char)a & ~b;
+  return (vector signed char)__a & ~__b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_andc(vector signed char a, vector bool char b)
+vec_andc(vector signed char __a, vector bool char __b)
 {
-  return a & ~(vector signed char)b;
+  return __a & ~(vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_andc(vector unsigned char a, vector unsigned char b)
+vec_andc(vector unsigned char __a, vector unsigned char __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_andc(vector bool char a, vector unsigned char b)
+vec_andc(vector bool char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)a & ~b;
+  return (vector unsigned char)__a & ~__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_andc(vector unsigned char a, vector bool char b)
+vec_andc(vector unsigned char __a, vector bool char __b)
 {
-  return a & ~(vector unsigned char)b;
+  return __a & ~(vector unsigned char)__b;
 }
 
 static vector bool char __ATTRS_o_ai
-vec_andc(vector bool char a, vector bool char b)
+vec_andc(vector bool char __a, vector bool char __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector short __ATTRS_o_ai
-vec_andc(vector short a, vector short b)
+vec_andc(vector short __a, vector short __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector short __ATTRS_o_ai
-vec_andc(vector bool short a, vector short b)
+vec_andc(vector bool short __a, vector short __b)
 {
-  return (vector short)a & ~b;
+  return (vector short)__a & ~__b;
 }
 
 static vector short __ATTRS_o_ai
-vec_andc(vector short a, vector bool short b)
+vec_andc(vector short __a, vector bool short __b)
 {
-  return a & ~(vector short)b;
+  return __a & ~(vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_andc(vector unsigned short a, vector unsigned short b)
+vec_andc(vector unsigned short __a, vector unsigned short __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_andc(vector bool short a, vector unsigned short b)
+vec_andc(vector bool short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)a & ~b;
+  return (vector unsigned short)__a & ~__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_andc(vector unsigned short a, vector bool short b)
+vec_andc(vector unsigned short __a, vector bool short __b)
 {
-  return a & ~(vector unsigned short)b;
+  return __a & ~(vector unsigned short)__b;
 }
 
 static vector bool short __ATTRS_o_ai
-vec_andc(vector bool short a, vector bool short b)
+vec_andc(vector bool short __a, vector bool short __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector int __ATTRS_o_ai
-vec_andc(vector int a, vector int b)
+vec_andc(vector int __a, vector int __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector int __ATTRS_o_ai
-vec_andc(vector bool int a, vector int b)
+vec_andc(vector bool int __a, vector int __b)
 {
-  return (vector int)a & ~b;
+  return (vector int)__a & ~__b;
 }
 
 static vector int __ATTRS_o_ai
-vec_andc(vector int a, vector bool int b)
+vec_andc(vector int __a, vector bool int __b)
 {
-  return a & ~(vector int)b;
+  return __a & ~(vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_andc(vector unsigned int a, vector unsigned int b)
+vec_andc(vector unsigned int __a, vector unsigned int __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_andc(vector bool int a, vector unsigned int b)
+vec_andc(vector bool int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)a & ~b;
+  return (vector unsigned int)__a & ~__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_andc(vector unsigned int a, vector bool int b)
+vec_andc(vector unsigned int __a, vector bool int __b)
 {
-  return a & ~(vector unsigned int)b;
+  return __a & ~(vector unsigned int)__b;
 }
 
 static vector bool int __ATTRS_o_ai
-vec_andc(vector bool int a, vector bool int b)
+vec_andc(vector bool int __a, vector bool int __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector float __ATTRS_o_ai
-vec_andc(vector float a, vector float b)
+vec_andc(vector float __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a & ~(vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a & ~(vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_andc(vector bool int a, vector float b)
+vec_andc(vector bool int __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a & ~(vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a & ~(vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_andc(vector float a, vector bool int b)
+vec_andc(vector float __a, vector bool int __b)
 {
-  vector unsigned int res = (vector unsigned int)a & ~(vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a & ~(vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 /* vec_vandc */
 
 static vector signed char __ATTRS_o_ai
-vec_vandc(vector signed char a, vector signed char b)
+vec_vandc(vector signed char __a, vector signed char __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vandc(vector bool char a, vector signed char b)
+vec_vandc(vector bool char __a, vector signed char __b)
 {
-  return (vector signed char)a & ~b;
+  return (vector signed char)__a & ~__b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vandc(vector signed char a, vector bool char b)
+vec_vandc(vector signed char __a, vector bool char __b)
 {
-  return a & ~(vector signed char)b;
+  return __a & ~(vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vandc(vector unsigned char a, vector unsigned char b)
+vec_vandc(vector unsigned char __a, vector unsigned char __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vandc(vector bool char a, vector unsigned char b)
+vec_vandc(vector bool char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)a & ~b;
+  return (vector unsigned char)__a & ~__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vandc(vector unsigned char a, vector bool char b)
+vec_vandc(vector unsigned char __a, vector bool char __b)
 {
-  return a & ~(vector unsigned char)b;
+  return __a & ~(vector unsigned char)__b;
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vandc(vector bool char a, vector bool char b)
+vec_vandc(vector bool char __a, vector bool char __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vandc(vector short a, vector short b)
+vec_vandc(vector short __a, vector short __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vandc(vector bool short a, vector short b)
+vec_vandc(vector bool short __a, vector short __b)
 {
-  return (vector short)a & ~b;
+  return (vector short)__a & ~__b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vandc(vector short a, vector bool short b)
+vec_vandc(vector short __a, vector bool short __b)
 {
-  return a & ~(vector short)b;
+  return __a & ~(vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vandc(vector unsigned short a, vector unsigned short b)
+vec_vandc(vector unsigned short __a, vector unsigned short __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vandc(vector bool short a, vector unsigned short b)
+vec_vandc(vector bool short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)a & ~b;
+  return (vector unsigned short)__a & ~__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vandc(vector unsigned short a, vector bool short b)
+vec_vandc(vector unsigned short __a, vector bool short __b)
 {
-  return a & ~(vector unsigned short)b;
+  return __a & ~(vector unsigned short)__b;
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vandc(vector bool short a, vector bool short b)
+vec_vandc(vector bool short __a, vector bool short __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vandc(vector int a, vector int b)
+vec_vandc(vector int __a, vector int __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vandc(vector bool int a, vector int b)
+vec_vandc(vector bool int __a, vector int __b)
 {
-  return (vector int)a & ~b;
+  return (vector int)__a & ~__b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vandc(vector int a, vector bool int b)
+vec_vandc(vector int __a, vector bool int __b)
 {
-  return a & ~(vector int)b;
+  return __a & ~(vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vandc(vector unsigned int a, vector unsigned int b)
+vec_vandc(vector unsigned int __a, vector unsigned int __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vandc(vector bool int a, vector unsigned int b)
+vec_vandc(vector bool int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)a & ~b;
+  return (vector unsigned int)__a & ~__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vandc(vector unsigned int a, vector bool int b)
+vec_vandc(vector unsigned int __a, vector bool int __b)
 {
-  return a & ~(vector unsigned int)b;
+  return __a & ~(vector unsigned int)__b;
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vandc(vector bool int a, vector bool int b)
+vec_vandc(vector bool int __a, vector bool int __b)
 {
-  return a & ~b;
+  return __a & ~__b;
 }
 
 static vector float __ATTRS_o_ai
-vec_vandc(vector float a, vector float b)
+vec_vandc(vector float __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a & ~(vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a & ~(vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_vandc(vector bool int a, vector float b)
+vec_vandc(vector bool int __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a & ~(vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a & ~(vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_vandc(vector float a, vector bool int b)
+vec_vandc(vector float __a, vector bool int __b)
 {
-  vector unsigned int res = (vector unsigned int)a & ~(vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a & ~(vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 /* vec_avg */
 
 static vector signed char __ATTRS_o_ai
-vec_avg(vector signed char a, vector signed char b)
+vec_avg(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vavgsb(a, b);
+  return __builtin_altivec_vavgsb(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_avg(vector unsigned char a, vector unsigned char b)
+vec_avg(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vavgub(a, b);
+  return __builtin_altivec_vavgub(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_avg(vector short a, vector short b)
+vec_avg(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vavgsh(a, b);
+  return __builtin_altivec_vavgsh(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_avg(vector unsigned short a, vector unsigned short b)
+vec_avg(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vavguh(a, b);
+  return __builtin_altivec_vavguh(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_avg(vector int a, vector int b)
+vec_avg(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vavgsw(a, b);
+  return __builtin_altivec_vavgsw(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_avg(vector unsigned int a, vector unsigned int b)
+vec_avg(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vavguw(a, b);
+  return __builtin_altivec_vavguw(__a, __b);
 }
 
 /* vec_vavgsb */
 
 static vector signed char __attribute__((__always_inline__))
-vec_vavgsb(vector signed char a, vector signed char b)
+vec_vavgsb(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vavgsb(a, b);
+  return __builtin_altivec_vavgsb(__a, __b);
 }
 
 /* vec_vavgub */
 
 static vector unsigned char __attribute__((__always_inline__))
-vec_vavgub(vector unsigned char a, vector unsigned char b)
+vec_vavgub(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vavgub(a, b);
+  return __builtin_altivec_vavgub(__a, __b);
 }
 
 /* vec_vavgsh */
 
 static vector short __attribute__((__always_inline__))
-vec_vavgsh(vector short a, vector short b)
+vec_vavgsh(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vavgsh(a, b);
+  return __builtin_altivec_vavgsh(__a, __b);
 }
 
 /* vec_vavguh */
 
 static vector unsigned short __attribute__((__always_inline__))
-vec_vavguh(vector unsigned short a, vector unsigned short b)
+vec_vavguh(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vavguh(a, b);
+  return __builtin_altivec_vavguh(__a, __b);
 }
 
 /* vec_vavgsw */
 
 static vector int __attribute__((__always_inline__))
-vec_vavgsw(vector int a, vector int b)
+vec_vavgsw(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vavgsw(a, b);
+  return __builtin_altivec_vavgsw(__a, __b);
 }
 
 /* vec_vavguw */
 
 static vector unsigned int __attribute__((__always_inline__))
-vec_vavguw(vector unsigned int a, vector unsigned int b)
+vec_vavguw(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vavguw(a, b);
+  return __builtin_altivec_vavguw(__a, __b);
 }
 
 /* vec_ceil */
 
 static vector float __attribute__((__always_inline__))
-vec_ceil(vector float a)
+vec_ceil(vector float __a)
 {
-  return __builtin_altivec_vrfip(a);
+  return __builtin_altivec_vrfip(__a);
 }
 
 /* vec_vrfip */
 
 static vector float __attribute__((__always_inline__))
-vec_vrfip(vector float a)
+vec_vrfip(vector float __a)
 {
-  return __builtin_altivec_vrfip(a);
+  return __builtin_altivec_vrfip(__a);
 }
 
 /* vec_cmpb */
 
 static vector int __attribute__((__always_inline__))
-vec_cmpb(vector float a, vector float b)
+vec_cmpb(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpbfp(a, b);
+  return __builtin_altivec_vcmpbfp(__a, __b);
 }
 
 /* vec_vcmpbfp */
 
 static vector int __attribute__((__always_inline__))
-vec_vcmpbfp(vector float a, vector float b)
+vec_vcmpbfp(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpbfp(a, b);
+  return __builtin_altivec_vcmpbfp(__a, __b);
 }
 
 /* vec_cmpeq */
 
 static vector bool char __ATTRS_o_ai
-vec_cmpeq(vector signed char a, vector signed char b)
+vec_cmpeq(vector signed char __a, vector signed char __b)
 {
   return (vector bool char)
-    __builtin_altivec_vcmpequb((vector char)a, (vector char)b);
+    __builtin_altivec_vcmpequb((vector char)__a, (vector char)__b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_cmpeq(vector unsigned char a, vector unsigned char b)
+vec_cmpeq(vector unsigned char __a, vector unsigned char __b)
 {
   return (vector bool char)
-    __builtin_altivec_vcmpequb((vector char)a, (vector char)b);
+    __builtin_altivec_vcmpequb((vector char)__a, (vector char)__b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_cmpeq(vector short a, vector short b)
+vec_cmpeq(vector short __a, vector short __b)
 {
-  return (vector bool short)__builtin_altivec_vcmpequh(a, b);
+  return (vector bool short)__builtin_altivec_vcmpequh(__a, __b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_cmpeq(vector unsigned short a, vector unsigned short b)
+vec_cmpeq(vector unsigned short __a, vector unsigned short __b)
 {
   return (vector bool short)
-    __builtin_altivec_vcmpequh((vector short)a, (vector short)b);
+    __builtin_altivec_vcmpequh((vector short)__a, (vector short)__b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_cmpeq(vector int a, vector int b)
+vec_cmpeq(vector int __a, vector int __b)
 {
-  return (vector bool int)__builtin_altivec_vcmpequw(a, b);
+  return (vector bool int)__builtin_altivec_vcmpequw(__a, __b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_cmpeq(vector unsigned int a, vector unsigned int b)
+vec_cmpeq(vector unsigned int __a, vector unsigned int __b)
 {
   return (vector bool int)
-    __builtin_altivec_vcmpequw((vector int)a, (vector int)b);
+    __builtin_altivec_vcmpequw((vector int)__a, (vector int)__b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_cmpeq(vector float a, vector float b)
+vec_cmpeq(vector float __a, vector float __b)
 {
-  return (vector bool int)__builtin_altivec_vcmpeqfp(a, b);
+  return (vector bool int)__builtin_altivec_vcmpeqfp(__a, __b);
 }
 
 /* vec_cmpge */
 
 static vector bool int __attribute__((__always_inline__))
-vec_cmpge(vector float a, vector float b)
+vec_cmpge(vector float __a, vector float __b)
 {
-  return (vector bool int)__builtin_altivec_vcmpgefp(a, b);
+  return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
 }
 
 /* vec_vcmpgefp */
 
 static vector bool int __attribute__((__always_inline__))
-vec_vcmpgefp(vector float a, vector float b)
+vec_vcmpgefp(vector float __a, vector float __b)
 {
-  return (vector bool int)__builtin_altivec_vcmpgefp(a, b);
+  return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
 }
 
 /* vec_cmpgt */
 
 static vector bool char __ATTRS_o_ai
-vec_cmpgt(vector signed char a, vector signed char b)
+vec_cmpgt(vector signed char __a, vector signed char __b)
 {
-  return (vector bool char)__builtin_altivec_vcmpgtsb(a, b);
+  return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_cmpgt(vector unsigned char a, vector unsigned char b)
+vec_cmpgt(vector unsigned char __a, vector unsigned char __b)
 {
-  return (vector bool char)__builtin_altivec_vcmpgtub(a, b);
+  return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_cmpgt(vector short a, vector short b)
+vec_cmpgt(vector short __a, vector short __b)
 {
-  return (vector bool short)__builtin_altivec_vcmpgtsh(a, b);
+  return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_cmpgt(vector unsigned short a, vector unsigned short b)
+vec_cmpgt(vector unsigned short __a, vector unsigned short __b)
 {
-  return (vector bool short)__builtin_altivec_vcmpgtuh(a, b);
+  return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_cmpgt(vector int a, vector int b)
+vec_cmpgt(vector int __a, vector int __b)
 {
-  return (vector bool int)__builtin_altivec_vcmpgtsw(a, b);
+  return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_cmpgt(vector unsigned int a, vector unsigned int b)
+vec_cmpgt(vector unsigned int __a, vector unsigned int __b)
 {
-  return (vector bool int)__builtin_altivec_vcmpgtuw(a, b);
+  return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_cmpgt(vector float a, vector float b)
+vec_cmpgt(vector float __a, vector float __b)
 {
-  return (vector bool int)__builtin_altivec_vcmpgtfp(a, b);
+  return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
 }
 
 /* vec_vcmpgtsb */
 
 static vector bool char __attribute__((__always_inline__))
-vec_vcmpgtsb(vector signed char a, vector signed char b)
+vec_vcmpgtsb(vector signed char __a, vector signed char __b)
 {
-  return (vector bool char)__builtin_altivec_vcmpgtsb(a, b);
+  return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
 }
 
 /* vec_vcmpgtub */
 
 static vector bool char __attribute__((__always_inline__))
-vec_vcmpgtub(vector unsigned char a, vector unsigned char b)
+vec_vcmpgtub(vector unsigned char __a, vector unsigned char __b)
 {
-  return (vector bool char)__builtin_altivec_vcmpgtub(a, b);
+  return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
 }
 
 /* vec_vcmpgtsh */
 
 static vector bool short __attribute__((__always_inline__))
-vec_vcmpgtsh(vector short a, vector short b)
+vec_vcmpgtsh(vector short __a, vector short __b)
 {
-  return (vector bool short)__builtin_altivec_vcmpgtsh(a, b);
+  return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
 }
 
 /* vec_vcmpgtuh */
 
 static vector bool short __attribute__((__always_inline__))
-vec_vcmpgtuh(vector unsigned short a, vector unsigned short b)
+vec_vcmpgtuh(vector unsigned short __a, vector unsigned short __b)
 {
-  return (vector bool short)__builtin_altivec_vcmpgtuh(a, b);
+  return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
 }
 
 /* vec_vcmpgtsw */
 
 static vector bool int __attribute__((__always_inline__))
-vec_vcmpgtsw(vector int a, vector int b)
+vec_vcmpgtsw(vector int __a, vector int __b)
 {
-  return (vector bool int)__builtin_altivec_vcmpgtsw(a, b);
+  return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
 }
 
 /* vec_vcmpgtuw */
 
 static vector bool int __attribute__((__always_inline__))
-vec_vcmpgtuw(vector unsigned int a, vector unsigned int b)
+vec_vcmpgtuw(vector unsigned int __a, vector unsigned int __b)
 {
-  return (vector bool int)__builtin_altivec_vcmpgtuw(a, b);
+  return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
 }
 
 /* vec_vcmpgtfp */
 
 static vector bool int __attribute__((__always_inline__))
-vec_vcmpgtfp(vector float a, vector float b)
+vec_vcmpgtfp(vector float __a, vector float __b)
 {
-  return (vector bool int)__builtin_altivec_vcmpgtfp(a, b);
+  return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
 }
 
 /* vec_cmple */
 
 static vector bool int __attribute__((__always_inline__))
-vec_cmple(vector float a, vector float b)
+vec_cmple(vector float __a, vector float __b)
 {
-  return (vector bool int)__builtin_altivec_vcmpgefp(b, a);
+  return (vector bool int)__builtin_altivec_vcmpgefp(__b, __a);
 }
 
 /* vec_cmplt */
 
 static vector bool char __ATTRS_o_ai
-vec_cmplt(vector signed char a, vector signed char b)
+vec_cmplt(vector signed char __a, vector signed char __b)
 {
-  return (vector bool char)__builtin_altivec_vcmpgtsb(b, a);
+  return (vector bool char)__builtin_altivec_vcmpgtsb(__b, __a);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_cmplt(vector unsigned char a, vector unsigned char b)
+vec_cmplt(vector unsigned char __a, vector unsigned char __b)
 {
-  return (vector bool char)__builtin_altivec_vcmpgtub(b, a);
+  return (vector bool char)__builtin_altivec_vcmpgtub(__b, __a);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_cmplt(vector short a, vector short b)
+vec_cmplt(vector short __a, vector short __b)
 {
-  return (vector bool short)__builtin_altivec_vcmpgtsh(b, a);
+  return (vector bool short)__builtin_altivec_vcmpgtsh(__b, __a);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_cmplt(vector unsigned short a, vector unsigned short b)
+vec_cmplt(vector unsigned short __a, vector unsigned short __b)
 {
-  return (vector bool short)__builtin_altivec_vcmpgtuh(b, a);
+  return (vector bool short)__builtin_altivec_vcmpgtuh(__b, __a);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_cmplt(vector int a, vector int b)
+vec_cmplt(vector int __a, vector int __b)
 {
-  return (vector bool int)__builtin_altivec_vcmpgtsw(b, a);
+  return (vector bool int)__builtin_altivec_vcmpgtsw(__b, __a);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_cmplt(vector unsigned int a, vector unsigned int b)
+vec_cmplt(vector unsigned int __a, vector unsigned int __b)
 {
-  return (vector bool int)__builtin_altivec_vcmpgtuw(b, a);
+  return (vector bool int)__builtin_altivec_vcmpgtuw(__b, __a);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_cmplt(vector float a, vector float b)
+vec_cmplt(vector float __a, vector float __b)
 {
-  return (vector bool int)__builtin_altivec_vcmpgtfp(b, a);
+  return (vector bool int)__builtin_altivec_vcmpgtfp(__b, __a);
 }
 
 /* vec_ctf */
 
 static vector float __ATTRS_o_ai
-vec_ctf(vector int a, int b)
+vec_ctf(vector int __a, int __b)
 {
-  return __builtin_altivec_vcfsx(a, b);
+  return __builtin_altivec_vcfsx(__a, __b);
 }
 
 static vector float __ATTRS_o_ai
-vec_ctf(vector unsigned int a, int b)
+vec_ctf(vector unsigned int __a, int __b)
 {
-  return __builtin_altivec_vcfux((vector int)a, b);
+  return __builtin_altivec_vcfux((vector int)__a, __b);
 }
 
 /* vec_vcfsx */
 
 static vector float __attribute__((__always_inline__))
-vec_vcfsx(vector int a, int b)
+vec_vcfsx(vector int __a, int __b)
 {
-  return __builtin_altivec_vcfsx(a, b);
+  return __builtin_altivec_vcfsx(__a, __b);
 }
 
 /* vec_vcfux */
 
 static vector float __attribute__((__always_inline__))
-vec_vcfux(vector unsigned int a, int b)
+vec_vcfux(vector unsigned int __a, int __b)
 {
-  return __builtin_altivec_vcfux((vector int)a, b);
+  return __builtin_altivec_vcfux((vector int)__a, __b);
 }
 
 /* vec_cts */
 
 static vector int __attribute__((__always_inline__))
-vec_cts(vector float a, int b)
+vec_cts(vector float __a, int __b)
 {
-  return __builtin_altivec_vctsxs(a, b);
+  return __builtin_altivec_vctsxs(__a, __b);
 }
 
 /* vec_vctsxs */
 
 static vector int __attribute__((__always_inline__))
-vec_vctsxs(vector float a, int b)
+vec_vctsxs(vector float __a, int __b)
 {
-  return __builtin_altivec_vctsxs(a, b);
+  return __builtin_altivec_vctsxs(__a, __b);
 }
 
 /* vec_ctu */
 
 static vector unsigned int __attribute__((__always_inline__))
-vec_ctu(vector float a, int b)
+vec_ctu(vector float __a, int __b)
 {
-  return __builtin_altivec_vctuxs(a, b);
+  return __builtin_altivec_vctuxs(__a, __b);
 }
 
 /* vec_vctuxs */
 
 static vector unsigned int __attribute__((__always_inline__))
-vec_vctuxs(vector float a, int b)
+vec_vctuxs(vector float __a, int __b)
 {
-  return __builtin_altivec_vctuxs(a, b);
+  return __builtin_altivec_vctuxs(__a, __b);
 }
 
 /* vec_dss */
 
 static void __attribute__((__always_inline__))
-vec_dss(int a)
+vec_dss(int __a)
 {
-  __builtin_altivec_dss(a);
+  __builtin_altivec_dss(__a);
 }
 
 /* vec_dssall */
@@ -1639,1066 +1639,1066 @@
 /* vec_dst */
 
 static void __attribute__((__always_inline__))
-vec_dst(const void *a, int b, int c)
+vec_dst(const void *__a, int __b, int __c)
 {
-  __builtin_altivec_dst(a, b, c);
+  __builtin_altivec_dst(__a, __b, __c);
 }
 
 /* vec_dstst */
 
 static void __attribute__((__always_inline__))
-vec_dstst(const void *a, int b, int c)
+vec_dstst(const void *__a, int __b, int __c)
 {
-  __builtin_altivec_dstst(a, b, c);
+  __builtin_altivec_dstst(__a, __b, __c);
 }
 
 /* vec_dststt */
 
 static void __attribute__((__always_inline__))
-vec_dststt(const void *a, int b, int c)
+vec_dststt(const void *__a, int __b, int __c)
 {
-  __builtin_altivec_dststt(a, b, c);
+  __builtin_altivec_dststt(__a, __b, __c);
 }
 
 /* vec_dstt */
 
 static void __attribute__((__always_inline__))
-vec_dstt(const void *a, int b, int c)
+vec_dstt(const void *__a, int __b, int __c)
 {
-  __builtin_altivec_dstt(a, b, c);
+  __builtin_altivec_dstt(__a, __b, __c);
 }
 
 /* vec_expte */
 
 static vector float __attribute__((__always_inline__))
-vec_expte(vector float a)
+vec_expte(vector float __a)
 {
-  return __builtin_altivec_vexptefp(a);
+  return __builtin_altivec_vexptefp(__a);
 }
 
 /* vec_vexptefp */
 
 static vector float __attribute__((__always_inline__))
-vec_vexptefp(vector float a)
+vec_vexptefp(vector float __a)
 {
-  return __builtin_altivec_vexptefp(a);
+  return __builtin_altivec_vexptefp(__a);
 }
 
 /* vec_floor */
 
 static vector float __attribute__((__always_inline__))
-vec_floor(vector float a)
+vec_floor(vector float __a)
 {
-  return __builtin_altivec_vrfim(a);
+  return __builtin_altivec_vrfim(__a);
 }
 
 /* vec_vrfim */
 
 static vector float __attribute__((__always_inline__))
-vec_vrfim(vector float a)
+vec_vrfim(vector float __a)
 {
-  return __builtin_altivec_vrfim(a);
+  return __builtin_altivec_vrfim(__a);
 }
 
 /* vec_ld */
 
 static vector signed char __ATTRS_o_ai
-vec_ld(int a, const vector signed char *b)
+vec_ld(int __a, const vector signed char *__b)
 {
-  return (vector signed char)__builtin_altivec_lvx(a, b);
+  return (vector signed char)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_ld(int a, const signed char *b)
+vec_ld(int __a, const signed char *__b)
 {
-  return (vector signed char)__builtin_altivec_lvx(a, b);
+  return (vector signed char)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_ld(int a, const vector unsigned char *b)
+vec_ld(int __a, const vector unsigned char *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvx(a, b);
+  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_ld(int a, const unsigned char *b)
+vec_ld(int __a, const unsigned char *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvx(a, b);
+  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_ld(int a, const vector bool char *b)
+vec_ld(int __a, const vector bool char *__b)
 {
-  return (vector bool char)__builtin_altivec_lvx(a, b);
+  return (vector bool char)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_ld(int a, const vector short *b)
+vec_ld(int __a, const vector short *__b)
 {
-  return (vector short)__builtin_altivec_lvx(a, b);
+  return (vector short)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_ld(int a, const short *b)
+vec_ld(int __a, const short *__b)
 {
-  return (vector short)__builtin_altivec_lvx(a, b);
+  return (vector short)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_ld(int a, const vector unsigned short *b)
+vec_ld(int __a, const vector unsigned short *__b)
 {
-  return (vector unsigned short)__builtin_altivec_lvx(a, b);
+  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_ld(int a, const unsigned short *b)
+vec_ld(int __a, const unsigned short *__b)
 {
-  return (vector unsigned short)__builtin_altivec_lvx(a, b);
+  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_ld(int a, const vector bool short *b)
+vec_ld(int __a, const vector bool short *__b)
 {
-  return (vector bool short)__builtin_altivec_lvx(a, b);
+  return (vector bool short)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_ld(int a, const vector pixel *b)
+vec_ld(int __a, const vector pixel *__b)
 {
-  return (vector pixel)__builtin_altivec_lvx(a, b);
+  return (vector pixel)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_ld(int a, const vector int *b)
+vec_ld(int __a, const vector int *__b)
 {
-  return (vector int)__builtin_altivec_lvx(a, b);
+  return (vector int)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_ld(int a, const int *b)
+vec_ld(int __a, const int *__b)
 {
-  return (vector int)__builtin_altivec_lvx(a, b);
+  return (vector int)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_ld(int a, const vector unsigned int *b)
+vec_ld(int __a, const vector unsigned int *__b)
 {
-  return (vector unsigned int)__builtin_altivec_lvx(a, b);
+  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_ld(int a, const unsigned int *b)
+vec_ld(int __a, const unsigned int *__b)
 {
-  return (vector unsigned int)__builtin_altivec_lvx(a, b);
+  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_ld(int a, const vector bool int *b)
+vec_ld(int __a, const vector bool int *__b)
 {
-  return (vector bool int)__builtin_altivec_lvx(a, b);
+  return (vector bool int)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector float __ATTRS_o_ai
-vec_ld(int a, const vector float *b)
+vec_ld(int __a, const vector float *__b)
 {
-  return (vector float)__builtin_altivec_lvx(a, b);
+  return (vector float)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector float __ATTRS_o_ai
-vec_ld(int a, const float *b)
+vec_ld(int __a, const float *__b)
 {
-  return (vector float)__builtin_altivec_lvx(a, b);
+  return (vector float)__builtin_altivec_lvx(__a, __b);
 }
 
 /* vec_lvx */
 
 static vector signed char __ATTRS_o_ai
-vec_lvx(int a, const vector signed char *b)
+vec_lvx(int __a, const vector signed char *__b)
 {
-  return (vector signed char)__builtin_altivec_lvx(a, b);
+  return (vector signed char)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_lvx(int a, const signed char *b)
+vec_lvx(int __a, const signed char *__b)
 {
-  return (vector signed char)__builtin_altivec_lvx(a, b);
+  return (vector signed char)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvx(int a, const vector unsigned char *b)
+vec_lvx(int __a, const vector unsigned char *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvx(a, b);
+  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvx(int a, const unsigned char *b)
+vec_lvx(int __a, const unsigned char *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvx(a, b);
+  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_lvx(int a, const vector bool char *b)
+vec_lvx(int __a, const vector bool char *__b)
 {
-  return (vector bool char)__builtin_altivec_lvx(a, b);
+  return (vector bool char)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_lvx(int a, const vector short *b)
+vec_lvx(int __a, const vector short *__b)
 {
-  return (vector short)__builtin_altivec_lvx(a, b);
+  return (vector short)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_lvx(int a, const short *b)
+vec_lvx(int __a, const short *__b)
 {
-  return (vector short)__builtin_altivec_lvx(a, b);
+  return (vector short)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_lvx(int a, const vector unsigned short *b)
+vec_lvx(int __a, const vector unsigned short *__b)
 {
-  return (vector unsigned short)__builtin_altivec_lvx(a, b);
+  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_lvx(int a, const unsigned short *b)
+vec_lvx(int __a, const unsigned short *__b)
 {
-  return (vector unsigned short)__builtin_altivec_lvx(a, b);
+  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_lvx(int a, const vector bool short *b)
+vec_lvx(int __a, const vector bool short *__b)
 {
-  return (vector bool short)__builtin_altivec_lvx(a, b);
+  return (vector bool short)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_lvx(int a, const vector pixel *b)
+vec_lvx(int __a, const vector pixel *__b)
 {
-  return (vector pixel)__builtin_altivec_lvx(a, b);
+  return (vector pixel)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_lvx(int a, const vector int *b)
+vec_lvx(int __a, const vector int *__b)
 {
-  return (vector int)__builtin_altivec_lvx(a, b);
+  return (vector int)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_lvx(int a, const int *b)
+vec_lvx(int __a, const int *__b)
 {
-  return (vector int)__builtin_altivec_lvx(a, b);
+  return (vector int)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_lvx(int a, const vector unsigned int *b)
+vec_lvx(int __a, const vector unsigned int *__b)
 {
-  return (vector unsigned int)__builtin_altivec_lvx(a, b);
+  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_lvx(int a, const unsigned int *b)
+vec_lvx(int __a, const unsigned int *__b)
 {
-  return (vector unsigned int)__builtin_altivec_lvx(a, b);
+  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_lvx(int a, const vector bool int *b)
+vec_lvx(int __a, const vector bool int *__b)
 {
-  return (vector bool int)__builtin_altivec_lvx(a, b);
+  return (vector bool int)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector float __ATTRS_o_ai
-vec_lvx(int a, const vector float *b)
+vec_lvx(int __a, const vector float *__b)
 {
-  return (vector float)__builtin_altivec_lvx(a, b);
+  return (vector float)__builtin_altivec_lvx(__a, __b);
 }
 
 static vector float __ATTRS_o_ai
-vec_lvx(int a, const float *b)
+vec_lvx(int __a, const float *__b)
 {
-  return (vector float)__builtin_altivec_lvx(a, b);
+  return (vector float)__builtin_altivec_lvx(__a, __b);
 }
 
 /* vec_lde */
 
 static vector signed char __ATTRS_o_ai
-vec_lde(int a, const vector signed char *b)
+vec_lde(int __a, const signed char *__b)
 {
-  return (vector signed char)__builtin_altivec_lvebx(a, b);
+  return (vector signed char)__builtin_altivec_lvebx(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lde(int a, const vector unsigned char *b)
+vec_lde(int __a, const unsigned char *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvebx(a, b);
+  return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_lde(int a, const vector short *b)
+vec_lde(int __a, const short *__b)
 {
-  return (vector short)__builtin_altivec_lvehx(a, b);
+  return (vector short)__builtin_altivec_lvehx(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_lde(int a, const vector unsigned short *b)
+vec_lde(int __a, const unsigned short *__b)
 {
-  return (vector unsigned short)__builtin_altivec_lvehx(a, b);
+  return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_lde(int a, const vector int *b)
+vec_lde(int __a, const int *__b)
 {
-  return (vector int)__builtin_altivec_lvewx(a, b);
+  return (vector int)__builtin_altivec_lvewx(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_lde(int a, const vector unsigned int *b)
+vec_lde(int __a, const unsigned int *__b)
 {
-  return (vector unsigned int)__builtin_altivec_lvewx(a, b);
+  return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
 }
 
 static vector float __ATTRS_o_ai
-vec_lde(int a, const vector float *b)
+vec_lde(int __a, const float *__b)
 {
-  return (vector float)__builtin_altivec_lvewx(a, b);
+  return (vector float)__builtin_altivec_lvewx(__a, __b);
 }
 
 /* vec_lvebx */
 
 static vector signed char __ATTRS_o_ai
-vec_lvebx(int a, const vector signed char *b)
+vec_lvebx(int __a, const signed char *__b)
 {
-  return (vector signed char)__builtin_altivec_lvebx(a, b);
+  return (vector signed char)__builtin_altivec_lvebx(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvebx(int a, const vector unsigned char *b)
+vec_lvebx(int __a, const unsigned char *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvebx(a, b);
+  return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
 }
 
 /* vec_lvehx */
 
 static vector short __ATTRS_o_ai
-vec_lvehx(int a, const vector short *b)
+vec_lvehx(int __a, const short *__b)
 {
-  return (vector short)__builtin_altivec_lvehx(a, b);
+  return (vector short)__builtin_altivec_lvehx(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_lvehx(int a, const vector unsigned short *b)
+vec_lvehx(int __a, const unsigned short *__b)
 {
-  return (vector unsigned short)__builtin_altivec_lvehx(a, b);
+  return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
 }
 
 /* vec_lvewx */
 
 static vector int __ATTRS_o_ai
-vec_lvewx(int a, const vector int *b)
+vec_lvewx(int __a, const int *__b)
 {
-  return (vector int)__builtin_altivec_lvewx(a, b);
+  return (vector int)__builtin_altivec_lvewx(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_lvewx(int a, const vector unsigned int *b)
+vec_lvewx(int __a, const unsigned int *__b)
 {
-  return (vector unsigned int)__builtin_altivec_lvewx(a, b);
+  return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
 }
 
 static vector float __ATTRS_o_ai
-vec_lvewx(int a, const vector float *b)
+vec_lvewx(int __a, const float *__b)
 {
-  return (vector float)__builtin_altivec_lvewx(a, b);
+  return (vector float)__builtin_altivec_lvewx(__a, __b);
 }
 
 /* vec_ldl */
 
 static vector signed char __ATTRS_o_ai
-vec_ldl(int a, const vector signed char *b)
+vec_ldl(int __a, const vector signed char *__b)
 {
-  return (vector signed char)__builtin_altivec_lvxl(a, b);
+  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_ldl(int a, const signed char *b)
+vec_ldl(int __a, const signed char *__b)
 {
-  return (vector signed char)__builtin_altivec_lvxl(a, b);
+  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_ldl(int a, const vector unsigned char *b)
+vec_ldl(int __a, const vector unsigned char *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvxl(a, b);
+  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_ldl(int a, const unsigned char *b)
+vec_ldl(int __a, const unsigned char *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvxl(a, b);
+  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_ldl(int a, const vector bool char *b)
+vec_ldl(int __a, const vector bool char *__b)
 {
-  return (vector bool char)__builtin_altivec_lvxl(a, b);
+  return (vector bool char)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_ldl(int a, const vector short *b)
+vec_ldl(int __a, const vector short *__b)
 {
-  return (vector short)__builtin_altivec_lvxl(a, b);
+  return (vector short)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_ldl(int a, const short *b)
+vec_ldl(int __a, const short *__b)
 {
-  return (vector short)__builtin_altivec_lvxl(a, b);
+  return (vector short)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_ldl(int a, const vector unsigned short *b)
+vec_ldl(int __a, const vector unsigned short *__b)
 {
-  return (vector unsigned short)__builtin_altivec_lvxl(a, b);
+  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_ldl(int a, const unsigned short *b)
+vec_ldl(int __a, const unsigned short *__b)
 {
-  return (vector unsigned short)__builtin_altivec_lvxl(a, b);
+  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_ldl(int a, const vector bool short *b)
+vec_ldl(int __a, const vector bool short *__b)
 {
-  return (vector bool short)__builtin_altivec_lvxl(a, b);
+  return (vector bool short)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_ldl(int a, const vector pixel *b)
+vec_ldl(int __a, const vector pixel *__b)
 {
-  return (vector pixel short)__builtin_altivec_lvxl(a, b);
+  return (vector pixel short)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_ldl(int a, const vector int *b)
+vec_ldl(int __a, const vector int *__b)
 {
-  return (vector int)__builtin_altivec_lvxl(a, b);
+  return (vector int)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_ldl(int a, const int *b)
+vec_ldl(int __a, const int *__b)
 {
-  return (vector int)__builtin_altivec_lvxl(a, b);
+  return (vector int)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_ldl(int a, const vector unsigned int *b)
+vec_ldl(int __a, const vector unsigned int *__b)
 {
-  return (vector unsigned int)__builtin_altivec_lvxl(a, b);
+  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_ldl(int a, const unsigned int *b)
+vec_ldl(int __a, const unsigned int *__b)
 {
-  return (vector unsigned int)__builtin_altivec_lvxl(a, b);
+  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_ldl(int a, const vector bool int *b)
+vec_ldl(int __a, const vector bool int *__b)
 {
-  return (vector bool int)__builtin_altivec_lvxl(a, b);
+  return (vector bool int)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector float __ATTRS_o_ai
-vec_ldl(int a, const vector float *b)
+vec_ldl(int __a, const vector float *__b)
 {
-  return (vector float)__builtin_altivec_lvxl(a, b);
+  return (vector float)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector float __ATTRS_o_ai
-vec_ldl(int a, const float *b)
+vec_ldl(int __a, const float *__b)
 {
-  return (vector float)__builtin_altivec_lvxl(a, b);
+  return (vector float)__builtin_altivec_lvxl(__a, __b);
 }
 
 /* vec_lvxl */
 
 static vector signed char __ATTRS_o_ai
-vec_lvxl(int a, const vector signed char *b)
+vec_lvxl(int __a, const vector signed char *__b)
 {
-  return (vector signed char)__builtin_altivec_lvxl(a, b);
+  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_lvxl(int a, const signed char *b)
+vec_lvxl(int __a, const signed char *__b)
 {
-  return (vector signed char)__builtin_altivec_lvxl(a, b);
+  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvxl(int a, const vector unsigned char *b)
+vec_lvxl(int __a, const vector unsigned char *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvxl(a, b);
+  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvxl(int a, const unsigned char *b)
+vec_lvxl(int __a, const unsigned char *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvxl(a, b);
+  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_lvxl(int a, const vector bool char *b)
+vec_lvxl(int __a, const vector bool char *__b)
 {
-  return (vector bool char)__builtin_altivec_lvxl(a, b);
+  return (vector bool char)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_lvxl(int a, const vector short *b)
+vec_lvxl(int __a, const vector short *__b)
 {
-  return (vector short)__builtin_altivec_lvxl(a, b);
+  return (vector short)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_lvxl(int a, const short *b)
+vec_lvxl(int __a, const short *__b)
 {
-  return (vector short)__builtin_altivec_lvxl(a, b);
+  return (vector short)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_lvxl(int a, const vector unsigned short *b)
+vec_lvxl(int __a, const vector unsigned short *__b)
 {
-  return (vector unsigned short)__builtin_altivec_lvxl(a, b);
+  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_lvxl(int a, const unsigned short *b)
+vec_lvxl(int __a, const unsigned short *__b)
 {
-  return (vector unsigned short)__builtin_altivec_lvxl(a, b);
+  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_lvxl(int a, const vector bool short *b)
+vec_lvxl(int __a, const vector bool short *__b)
 {
-  return (vector bool short)__builtin_altivec_lvxl(a, b);
+  return (vector bool short)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_lvxl(int a, const vector pixel *b)
+vec_lvxl(int __a, const vector pixel *__b)
 {
-  return (vector pixel)__builtin_altivec_lvxl(a, b);
+  return (vector pixel)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_lvxl(int a, const vector int *b)
+vec_lvxl(int __a, const vector int *__b)
 {
-  return (vector int)__builtin_altivec_lvxl(a, b);
+  return (vector int)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_lvxl(int a, const int *b)
+vec_lvxl(int __a, const int *__b)
 {
-  return (vector int)__builtin_altivec_lvxl(a, b);
+  return (vector int)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_lvxl(int a, const vector unsigned int *b)
+vec_lvxl(int __a, const vector unsigned int *__b)
 {
-  return (vector unsigned int)__builtin_altivec_lvxl(a, b);
+  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_lvxl(int a, const unsigned int *b)
+vec_lvxl(int __a, const unsigned int *__b)
 {
-  return (vector unsigned int)__builtin_altivec_lvxl(a, b);
+  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_lvxl(int a, const vector bool int *b)
+vec_lvxl(int __a, const vector bool int *__b)
 {
-  return (vector bool int)__builtin_altivec_lvxl(a, b);
+  return (vector bool int)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector float __ATTRS_o_ai
-vec_lvxl(int a, const vector float *b)
+vec_lvxl(int __a, const vector float *__b)
 {
-  return (vector float)__builtin_altivec_lvxl(a, b);
+  return (vector float)__builtin_altivec_lvxl(__a, __b);
 }
 
 static vector float __ATTRS_o_ai
-vec_lvxl(int a, const float *b)
+vec_lvxl(int __a, const float *__b)
 {
-  return (vector float)__builtin_altivec_lvxl(a, b);
+  return (vector float)__builtin_altivec_lvxl(__a, __b);
 }
 
 /* vec_loge */
 
 static vector float __attribute__((__always_inline__))
-vec_loge(vector float a)
+vec_loge(vector float __a)
 {
-  return __builtin_altivec_vlogefp(a);
+  return __builtin_altivec_vlogefp(__a);
 }
 
 /* vec_vlogefp */
 
 static vector float __attribute__((__always_inline__))
-vec_vlogefp(vector float a)
+vec_vlogefp(vector float __a)
 {
-  return __builtin_altivec_vlogefp(a);
+  return __builtin_altivec_vlogefp(__a);
 }
 
 /* vec_lvsl */
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvsl(int a, const signed char *b)
+vec_lvsl(int __a, const signed char *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvsl(a, b);
+  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvsl(int a, const unsigned char *b)
+vec_lvsl(int __a, const unsigned char *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvsl(a, b);
+  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvsl(int a, const short *b)
+vec_lvsl(int __a, const short *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvsl(a, b);
+  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvsl(int a, const unsigned short *b)
+vec_lvsl(int __a, const unsigned short *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvsl(a, b);
+  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvsl(int a, const int *b)
+vec_lvsl(int __a, const int *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvsl(a, b);
+  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvsl(int a, const unsigned int *b)
+vec_lvsl(int __a, const unsigned int *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvsl(a, b);
+  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvsl(int a, const float *b)
+vec_lvsl(int __a, const float *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvsl(a, b);
+  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
 }
 
 /* vec_lvsr */
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvsr(int a, const signed char *b)
+vec_lvsr(int __a, const signed char *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvsr(a, b);
+  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvsr(int a, const unsigned char *b)
+vec_lvsr(int __a, const unsigned char *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvsr(a, b);
+  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvsr(int a, const short *b)
+vec_lvsr(int __a, const short *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvsr(a, b);
+  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvsr(int a, const unsigned short *b)
+vec_lvsr(int __a, const unsigned short *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvsr(a, b);
+  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvsr(int a, const int *b)
+vec_lvsr(int __a, const int *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvsr(a, b);
+  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvsr(int a, const unsigned int *b)
+vec_lvsr(int __a, const unsigned int *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvsr(a, b);
+  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvsr(int a, const float *b)
+vec_lvsr(int __a, const float *__b)
 {
-  return (vector unsigned char)__builtin_altivec_lvsr(a, b);
+  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
 }
 
 /* vec_madd */
 
 static vector float __attribute__((__always_inline__))
-vec_madd(vector float a, vector float b, vector float c)
+vec_madd(vector float __a, vector float __b, vector float __c)
 {
-  return __builtin_altivec_vmaddfp(a, b, c);
+  return __builtin_altivec_vmaddfp(__a, __b, __c);
 }
 
 /* vec_vmaddfp */
 
 static vector float __attribute__((__always_inline__))
-vec_vmaddfp(vector float a, vector float b, vector float c)
+vec_vmaddfp(vector float __a, vector float __b, vector float __c)
 {
-  return __builtin_altivec_vmaddfp(a, b, c);
+  return __builtin_altivec_vmaddfp(__a, __b, __c);
 }
 
 /* vec_madds */
 
 static vector signed short __attribute__((__always_inline__))
-vec_madds(vector signed short a, vector signed short b, vector signed short c)
+vec_madds(vector signed short __a, vector signed short __b, vector signed short __c)
 {
-  return __builtin_altivec_vmhaddshs(a, b, c);
+  return __builtin_altivec_vmhaddshs(__a, __b, __c);
 }
 
 /* vec_vmhaddshs */
 static vector signed short __attribute__((__always_inline__))
-vec_vmhaddshs(vector signed short a,
-              vector signed short b, 
-              vector signed short c)
+vec_vmhaddshs(vector signed short __a,
+              vector signed short __b,
+              vector signed short __c)
 {
-  return __builtin_altivec_vmhaddshs(a, b, c);
+  return __builtin_altivec_vmhaddshs(__a, __b, __c);
 }
 
 /* vec_max */
 
 static vector signed char __ATTRS_o_ai
-vec_max(vector signed char a, vector signed char b)
+vec_max(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vmaxsb(a, b);
+  return __builtin_altivec_vmaxsb(__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_max(vector bool char a, vector signed char b)
+vec_max(vector bool char __a, vector signed char __b)
 {
-  return __builtin_altivec_vmaxsb((vector signed char)a, b);
+  return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_max(vector signed char a, vector bool char b)
+vec_max(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vmaxsb(a, (vector signed char)b);
+  return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_max(vector unsigned char a, vector unsigned char b)
+vec_max(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vmaxub(a, b);
+  return __builtin_altivec_vmaxub(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_max(vector bool char a, vector unsigned char b)
+vec_max(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vmaxub((vector unsigned char)a, b);
+  return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_max(vector unsigned char a, vector bool char b)
+vec_max(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vmaxub(a, (vector unsigned char)b);
+  return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_max(vector short a, vector short b)
+vec_max(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vmaxsh(a, b);
+  return __builtin_altivec_vmaxsh(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_max(vector bool short a, vector short b)
+vec_max(vector bool short __a, vector short __b)
 {
-  return __builtin_altivec_vmaxsh((vector short)a, b);
+  return __builtin_altivec_vmaxsh((vector short)__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_max(vector short a, vector bool short b)
+vec_max(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vmaxsh(a, (vector short)b);
+  return __builtin_altivec_vmaxsh(__a, (vector short)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_max(vector unsigned short a, vector unsigned short b)
+vec_max(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vmaxuh(a, b);
+  return __builtin_altivec_vmaxuh(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_max(vector bool short a, vector unsigned short b)
+vec_max(vector bool short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vmaxuh((vector unsigned short)a, b);
+  return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_max(vector unsigned short a, vector bool short b)
+vec_max(vector unsigned short __a, vector bool short __b)
 {
-  return __builtin_altivec_vmaxuh(a, (vector unsigned short)b);
+  return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_max(vector int a, vector int b)
+vec_max(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vmaxsw(a, b);
+  return __builtin_altivec_vmaxsw(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_max(vector bool int a, vector int b)
+vec_max(vector bool int __a, vector int __b)
 {
-  return __builtin_altivec_vmaxsw((vector int)a, b);
+  return __builtin_altivec_vmaxsw((vector int)__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_max(vector int a, vector bool int b)
+vec_max(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vmaxsw(a, (vector int)b);
+  return __builtin_altivec_vmaxsw(__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_max(vector unsigned int a, vector unsigned int b)
+vec_max(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vmaxuw(a, b);
+  return __builtin_altivec_vmaxuw(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_max(vector bool int a, vector unsigned int b)
+vec_max(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vmaxuw((vector unsigned int)a, b);
+  return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_max(vector unsigned int a, vector bool int b)
+vec_max(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vmaxuw(a, (vector unsigned int)b);
+  return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
 }
 
 static vector float __ATTRS_o_ai
-vec_max(vector float a, vector float b)
+vec_max(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vmaxfp(a, b);
+  return __builtin_altivec_vmaxfp(__a, __b);
 }
 
 /* vec_vmaxsb */
 
 static vector signed char __ATTRS_o_ai
-vec_vmaxsb(vector signed char a, vector signed char b)
+vec_vmaxsb(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vmaxsb(a, b);
+  return __builtin_altivec_vmaxsb(__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vmaxsb(vector bool char a, vector signed char b)
+vec_vmaxsb(vector bool char __a, vector signed char __b)
 {
-  return __builtin_altivec_vmaxsb((vector signed char)a, b);
+  return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vmaxsb(vector signed char a, vector bool char b)
+vec_vmaxsb(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vmaxsb(a, (vector signed char)b);
+  return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
 }
 
 /* vec_vmaxub */
 
 static vector unsigned char __ATTRS_o_ai
-vec_vmaxub(vector unsigned char a, vector unsigned char b)
+vec_vmaxub(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vmaxub(a, b);
+  return __builtin_altivec_vmaxub(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vmaxub(vector bool char a, vector unsigned char b)
+vec_vmaxub(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vmaxub((vector unsigned char)a, b);
+  return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vmaxub(vector unsigned char a, vector bool char b)
+vec_vmaxub(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vmaxub(a, (vector unsigned char)b);
+  return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
 }
 
 /* vec_vmaxsh */
 
 static vector short __ATTRS_o_ai
-vec_vmaxsh(vector short a, vector short b)
+vec_vmaxsh(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vmaxsh(a, b);
+  return __builtin_altivec_vmaxsh(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vmaxsh(vector bool short a, vector short b)
+vec_vmaxsh(vector bool short __a, vector short __b)
 {
-  return __builtin_altivec_vmaxsh((vector short)a, b);
+  return __builtin_altivec_vmaxsh((vector short)__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vmaxsh(vector short a, vector bool short b)
+vec_vmaxsh(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vmaxsh(a, (vector short)b);
+  return __builtin_altivec_vmaxsh(__a, (vector short)__b);
 }
 
 /* vec_vmaxuh */
 
 static vector unsigned short __ATTRS_o_ai
-vec_vmaxuh(vector unsigned short a, vector unsigned short b)
+vec_vmaxuh(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vmaxuh(a, b);
+  return __builtin_altivec_vmaxuh(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vmaxuh(vector bool short a, vector unsigned short b)
+vec_vmaxuh(vector bool short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vmaxuh((vector unsigned short)a, b);
+  return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vmaxuh(vector unsigned short a, vector bool short b)
+vec_vmaxuh(vector unsigned short __a, vector bool short __b)
 {
-  return __builtin_altivec_vmaxuh(a, (vector unsigned short)b);
+  return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
 }
 
 /* vec_vmaxsw */
 
 static vector int __ATTRS_o_ai
-vec_vmaxsw(vector int a, vector int b)
+vec_vmaxsw(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vmaxsw(a, b);
+  return __builtin_altivec_vmaxsw(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vmaxsw(vector bool int a, vector int b)
+vec_vmaxsw(vector bool int __a, vector int __b)
 {
-  return __builtin_altivec_vmaxsw((vector int)a, b);
+  return __builtin_altivec_vmaxsw((vector int)__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vmaxsw(vector int a, vector bool int b)
+vec_vmaxsw(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vmaxsw(a, (vector int)b);
+  return __builtin_altivec_vmaxsw(__a, (vector int)__b);
 }
 
 /* vec_vmaxuw */
 
 static vector unsigned int __ATTRS_o_ai
-vec_vmaxuw(vector unsigned int a, vector unsigned int b)
+vec_vmaxuw(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vmaxuw(a, b);
+  return __builtin_altivec_vmaxuw(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vmaxuw(vector bool int a, vector unsigned int b)
+vec_vmaxuw(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vmaxuw((vector unsigned int)a, b);
+  return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vmaxuw(vector unsigned int a, vector bool int b)
+vec_vmaxuw(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vmaxuw(a, (vector unsigned int)b);
+  return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
 }
 
 /* vec_vmaxfp */
 
 static vector float __attribute__((__always_inline__))
-vec_vmaxfp(vector float a, vector float b)
+vec_vmaxfp(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vmaxfp(a, b);
+  return __builtin_altivec_vmaxfp(__a, __b);
 }
 
 /* vec_mergeh */
 
 static vector signed char __ATTRS_o_ai
-vec_mergeh(vector signed char a, vector signed char b)
+vec_mergeh(vector signed char __a, vector signed char __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x10, 0x01, 0x11, 0x02, 0x12, 0x03, 0x13, 
      0x04, 0x14, 0x05, 0x15, 0x06, 0x16, 0x07, 0x17));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_mergeh(vector unsigned char a, vector unsigned char b)
+vec_mergeh(vector unsigned char __a, vector unsigned char __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x10, 0x01, 0x11, 0x02, 0x12, 0x03, 0x13, 
      0x04, 0x14, 0x05, 0x15, 0x06, 0x16, 0x07, 0x17));
 }
 
 static vector bool char __ATTRS_o_ai
-vec_mergeh(vector bool char a, vector bool char b)
+vec_mergeh(vector bool char __a, vector bool char __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x10, 0x01, 0x11, 0x02, 0x12, 0x03, 0x13, 
      0x04, 0x14, 0x05, 0x15, 0x06, 0x16, 0x07, 0x17));
 }
 
 static vector short __ATTRS_o_ai
-vec_mergeh(vector short a, vector short b)
+vec_mergeh(vector short __a, vector short __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x01, 0x10, 0x11, 0x02, 0x03, 0x12, 0x13,
      0x04, 0x05, 0x14, 0x15, 0x06, 0x07, 0x16, 0x17));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_mergeh(vector unsigned short a, vector unsigned short b)
+vec_mergeh(vector unsigned short __a, vector unsigned short __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x01, 0x10, 0x11, 0x02, 0x03, 0x12, 0x13,
      0x04, 0x05, 0x14, 0x15, 0x06, 0x07, 0x16, 0x17));
 }
 
 static vector bool short __ATTRS_o_ai
-vec_mergeh(vector bool short a, vector bool short b)
+vec_mergeh(vector bool short __a, vector bool short __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x01, 0x10, 0x11, 0x02, 0x03, 0x12, 0x13,
      0x04, 0x05, 0x14, 0x15, 0x06, 0x07, 0x16, 0x17));
 }
 
 static vector pixel __ATTRS_o_ai
-vec_mergeh(vector pixel a, vector pixel b)
+vec_mergeh(vector pixel __a, vector pixel __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x01, 0x10, 0x11, 0x02, 0x03, 0x12, 0x13,
      0x04, 0x05, 0x14, 0x15, 0x06, 0x07, 0x16, 0x17));
 }
 
 static vector int __ATTRS_o_ai
-vec_mergeh(vector int a, vector int b)
+vec_mergeh(vector int __a, vector int __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13,
      0x04, 0x05, 0x06, 0x07, 0x14, 0x15, 0x16, 0x17));
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_mergeh(vector unsigned int a, vector unsigned int b)
+vec_mergeh(vector unsigned int __a, vector unsigned int __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13,
      0x04, 0x05, 0x06, 0x07, 0x14, 0x15, 0x16, 0x17));
 }
 
 static vector bool int __ATTRS_o_ai
-vec_mergeh(vector bool int a, vector bool int b)
+vec_mergeh(vector bool int __a, vector bool int __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13,
      0x04, 0x05, 0x06, 0x07, 0x14, 0x15, 0x16, 0x17));
 }
 
 static vector float __ATTRS_o_ai
-vec_mergeh(vector float a, vector float b)
+vec_mergeh(vector float __a, vector float __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13,
      0x04, 0x05, 0x06, 0x07, 0x14, 0x15, 0x16, 0x17));
 }
@@ -2708,25 +2708,25 @@
 #define __builtin_altivec_vmrghb vec_vmrghb
 
 static vector signed char __ATTRS_o_ai
-vec_vmrghb(vector signed char a, vector signed char b)
+vec_vmrghb(vector signed char __a, vector signed char __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x10, 0x01, 0x11, 0x02, 0x12, 0x03, 0x13, 
      0x04, 0x14, 0x05, 0x15, 0x06, 0x16, 0x07, 0x17));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vmrghb(vector unsigned char a, vector unsigned char b)
+vec_vmrghb(vector unsigned char __a, vector unsigned char __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x10, 0x01, 0x11, 0x02, 0x12, 0x03, 0x13, 
      0x04, 0x14, 0x05, 0x15, 0x06, 0x16, 0x07, 0x17));
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vmrghb(vector bool char a, vector bool char b)
+vec_vmrghb(vector bool char __a, vector bool char __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x10, 0x01, 0x11, 0x02, 0x12, 0x03, 0x13, 
      0x04, 0x14, 0x05, 0x15, 0x06, 0x16, 0x07, 0x17));
 }
@@ -2736,33 +2736,33 @@
 #define __builtin_altivec_vmrghh vec_vmrghh
 
 static vector short __ATTRS_o_ai
-vec_vmrghh(vector short a, vector short b)
+vec_vmrghh(vector short __a, vector short __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x01, 0x10, 0x11, 0x02, 0x03, 0x12, 0x13,
      0x04, 0x05, 0x14, 0x15, 0x06, 0x07, 0x16, 0x17));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vmrghh(vector unsigned short a, vector unsigned short b)
+vec_vmrghh(vector unsigned short __a, vector unsigned short __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x01, 0x10, 0x11, 0x02, 0x03, 0x12, 0x13,
      0x04, 0x05, 0x14, 0x15, 0x06, 0x07, 0x16, 0x17));
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vmrghh(vector bool short a, vector bool short b)
+vec_vmrghh(vector bool short __a, vector bool short __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x01, 0x10, 0x11, 0x02, 0x03, 0x12, 0x13,
      0x04, 0x05, 0x14, 0x15, 0x06, 0x07, 0x16, 0x17));
 }
 
 static vector pixel __ATTRS_o_ai
-vec_vmrghh(vector pixel a, vector pixel b)
+vec_vmrghh(vector pixel __a, vector pixel __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x01, 0x10, 0x11, 0x02, 0x03, 0x12, 0x13,
      0x04, 0x05, 0x14, 0x15, 0x06, 0x07, 0x16, 0x17));
 }
@@ -2772,33 +2772,33 @@
 #define __builtin_altivec_vmrghw vec_vmrghw
 
 static vector int __ATTRS_o_ai
-vec_vmrghw(vector int a, vector int b)
+vec_vmrghw(vector int __a, vector int __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13,
      0x04, 0x05, 0x06, 0x07, 0x14, 0x15, 0x16, 0x17));
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vmrghw(vector unsigned int a, vector unsigned int b)
+vec_vmrghw(vector unsigned int __a, vector unsigned int __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13,
      0x04, 0x05, 0x06, 0x07, 0x14, 0x15, 0x16, 0x17));
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vmrghw(vector bool int a, vector bool int b)
+vec_vmrghw(vector bool int __a, vector bool int __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13,
      0x04, 0x05, 0x06, 0x07, 0x14, 0x15, 0x16, 0x17));
 }
 
 static vector float __ATTRS_o_ai
-vec_vmrghw(vector float a, vector float b)
+vec_vmrghw(vector float __a, vector float __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13,
      0x04, 0x05, 0x06, 0x07, 0x14, 0x15, 0x16, 0x17));
 }
@@ -2806,89 +2806,89 @@
 /* vec_mergel */
 
 static vector signed char __ATTRS_o_ai
-vec_mergel(vector signed char a, vector signed char b)
+vec_mergel(vector signed char __a, vector signed char __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A, 0x0B, 0x1B, 
      0x0C, 0x1C, 0x0D, 0x1D, 0x0E, 0x1E, 0x0F, 0x1F));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_mergel(vector unsigned char a, vector unsigned char b)
+vec_mergel(vector unsigned char __a, vector unsigned char __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A, 0x0B, 0x1B, 
      0x0C, 0x1C, 0x0D, 0x1D, 0x0E, 0x1E, 0x0F, 0x1F));
 }
 
 static vector bool char __ATTRS_o_ai
-vec_mergel(vector bool char a, vector bool char b)
+vec_mergel(vector bool char __a, vector bool char __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A, 0x0B, 0x1B, 
      0x0C, 0x1C, 0x0D, 0x1D, 0x0E, 0x1E, 0x0F, 0x1F));
 }
 
 static vector short __ATTRS_o_ai
-vec_mergel(vector short a, vector short b)
+vec_mergel(vector short __a, vector short __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B, 0x1A, 0x1B,
      0x0C, 0x0D, 0x1C, 0x1D, 0x0E, 0x0F, 0x1E, 0x1F));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_mergel(vector unsigned short a, vector unsigned short b)
+vec_mergel(vector unsigned short __a, vector unsigned short __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B, 0x1A, 0x1B,
      0x0C, 0x0D, 0x1C, 0x1D, 0x0E, 0x0F, 0x1E, 0x1F));
 }
 
 static vector bool short __ATTRS_o_ai
-vec_mergel(vector bool short a, vector bool short b)
+vec_mergel(vector bool short __a, vector bool short __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B, 0x1A, 0x1B,
      0x0C, 0x0D, 0x1C, 0x1D, 0x0E, 0x0F, 0x1E, 0x1F));
 }
 
 static vector pixel __ATTRS_o_ai
-vec_mergel(vector pixel a, vector pixel b)
+vec_mergel(vector pixel __a, vector pixel __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B, 0x1A, 0x1B,
      0x0C, 0x0D, 0x1C, 0x1D, 0x0E, 0x0F, 0x1E, 0x1F));
 }
 
 static vector int __ATTRS_o_ai
-vec_mergel(vector int a, vector int b)
+vec_mergel(vector int __a, vector int __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19, 0x1A, 0x1B,
      0x0C, 0x0D, 0x0E, 0x0F, 0x1C, 0x1D, 0x1E, 0x1F));
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_mergel(vector unsigned int a, vector unsigned int b)
+vec_mergel(vector unsigned int __a, vector unsigned int __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19, 0x1A, 0x1B,
      0x0C, 0x0D, 0x0E, 0x0F, 0x1C, 0x1D, 0x1E, 0x1F));
 }
 
 static vector bool int __ATTRS_o_ai
-vec_mergel(vector bool int a, vector bool int b)
+vec_mergel(vector bool int __a, vector bool int __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19, 0x1A, 0x1B,
      0x0C, 0x0D, 0x0E, 0x0F, 0x1C, 0x1D, 0x1E, 0x1F));
 }
 
 static vector float __ATTRS_o_ai
-vec_mergel(vector float a, vector float b)
+vec_mergel(vector float __a, vector float __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19, 0x1A, 0x1B,
      0x0C, 0x0D, 0x0E, 0x0F, 0x1C, 0x1D, 0x1E, 0x1F));
 }
@@ -2898,25 +2898,25 @@
 #define __builtin_altivec_vmrglb vec_vmrglb
 
 static vector signed char __ATTRS_o_ai
-vec_vmrglb(vector signed char a, vector signed char b)
+vec_vmrglb(vector signed char __a, vector signed char __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A, 0x0B, 0x1B, 
      0x0C, 0x1C, 0x0D, 0x1D, 0x0E, 0x1E, 0x0F, 0x1F));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vmrglb(vector unsigned char a, vector unsigned char b)
+vec_vmrglb(vector unsigned char __a, vector unsigned char __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A, 0x0B, 0x1B, 
      0x0C, 0x1C, 0x0D, 0x1D, 0x0E, 0x1E, 0x0F, 0x1F));
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vmrglb(vector bool char a, vector bool char b)
+vec_vmrglb(vector bool char __a, vector bool char __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A, 0x0B, 0x1B, 
      0x0C, 0x1C, 0x0D, 0x1D, 0x0E, 0x1E, 0x0F, 0x1F));
 }
@@ -2926,33 +2926,33 @@
 #define __builtin_altivec_vmrglh vec_vmrglh
 
 static vector short __ATTRS_o_ai
-vec_vmrglh(vector short a, vector short b)
+vec_vmrglh(vector short __a, vector short __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B, 0x1A, 0x1B,
      0x0C, 0x0D, 0x1C, 0x1D, 0x0E, 0x0F, 0x1E, 0x1F));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vmrglh(vector unsigned short a, vector unsigned short b)
+vec_vmrglh(vector unsigned short __a, vector unsigned short __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B, 0x1A, 0x1B,
      0x0C, 0x0D, 0x1C, 0x1D, 0x0E, 0x0F, 0x1E, 0x1F));
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vmrglh(vector bool short a, vector bool short b)
+vec_vmrglh(vector bool short __a, vector bool short __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B, 0x1A, 0x1B,
      0x0C, 0x0D, 0x1C, 0x1D, 0x0E, 0x0F, 0x1E, 0x1F));
 }
 
 static vector pixel __ATTRS_o_ai
-vec_vmrglh(vector pixel a, vector pixel b)
+vec_vmrglh(vector pixel __a, vector pixel __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B, 0x1A, 0x1B,
      0x0C, 0x0D, 0x1C, 0x1D, 0x0E, 0x0F, 0x1E, 0x1F));
 }
@@ -2962,33 +2962,33 @@
 #define __builtin_altivec_vmrglw vec_vmrglw
 
 static vector int __ATTRS_o_ai
-vec_vmrglw(vector int a, vector int b)
+vec_vmrglw(vector int __a, vector int __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19, 0x1A, 0x1B,
      0x0C, 0x0D, 0x0E, 0x0F, 0x1C, 0x1D, 0x1E, 0x1F));
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vmrglw(vector unsigned int a, vector unsigned int b)
+vec_vmrglw(vector unsigned int __a, vector unsigned int __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19, 0x1A, 0x1B,
      0x0C, 0x0D, 0x0E, 0x0F, 0x1C, 0x1D, 0x1E, 0x1F));
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vmrglw(vector bool int a, vector bool int b)
+vec_vmrglw(vector bool int __a, vector bool int __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19, 0x1A, 0x1B,
      0x0C, 0x0D, 0x0E, 0x0F, 0x1C, 0x1D, 0x1E, 0x1F));
 }
 
 static vector float __ATTRS_o_ai
-vec_vmrglw(vector float a, vector float b)
+vec_vmrglw(vector float __a, vector float __b)
 {
-  return vec_perm(a, b, (vector unsigned char)
+  return vec_perm(__a, __b, (vector unsigned char)
     (0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19, 0x1A, 0x1B,
      0x0C, 0x0D, 0x0E, 0x0F, 0x1C, 0x1D, 0x1E, 0x1F));
 }
@@ -3004,245 +3004,245 @@
 /* vec_min */
 
 static vector signed char __ATTRS_o_ai
-vec_min(vector signed char a, vector signed char b)
+vec_min(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vminsb(a, b);
+  return __builtin_altivec_vminsb(__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_min(vector bool char a, vector signed char b)
+vec_min(vector bool char __a, vector signed char __b)
 {
-  return __builtin_altivec_vminsb((vector signed char)a, b);
+  return __builtin_altivec_vminsb((vector signed char)__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_min(vector signed char a, vector bool char b)
+vec_min(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vminsb(a, (vector signed char)b);
+  return __builtin_altivec_vminsb(__a, (vector signed char)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_min(vector unsigned char a, vector unsigned char b)
+vec_min(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vminub(a, b);
+  return __builtin_altivec_vminub(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_min(vector bool char a, vector unsigned char b)
+vec_min(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vminub((vector unsigned char)a, b);
+  return __builtin_altivec_vminub((vector unsigned char)__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_min(vector unsigned char a, vector bool char b)
+vec_min(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vminub(a, (vector unsigned char)b);
+  return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_min(vector short a, vector short b)
+vec_min(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vminsh(a, b);
+  return __builtin_altivec_vminsh(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_min(vector bool short a, vector short b)
+vec_min(vector bool short __a, vector short __b)
 {
-  return __builtin_altivec_vminsh((vector short)a, b);
+  return __builtin_altivec_vminsh((vector short)__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_min(vector short a, vector bool short b)
+vec_min(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vminsh(a, (vector short)b);
+  return __builtin_altivec_vminsh(__a, (vector short)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_min(vector unsigned short a, vector unsigned short b)
+vec_min(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vminuh(a, b);
+  return __builtin_altivec_vminuh(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_min(vector bool short a, vector unsigned short b)
+vec_min(vector bool short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vminuh((vector unsigned short)a, b);
+  return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_min(vector unsigned short a, vector bool short b)
+vec_min(vector unsigned short __a, vector bool short __b)
 {
-  return __builtin_altivec_vminuh(a, (vector unsigned short)b);
+  return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_min(vector int a, vector int b)
+vec_min(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vminsw(a, b);
+  return __builtin_altivec_vminsw(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_min(vector bool int a, vector int b)
+vec_min(vector bool int __a, vector int __b)
 {
-  return __builtin_altivec_vminsw((vector int)a, b);
+  return __builtin_altivec_vminsw((vector int)__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_min(vector int a, vector bool int b)
+vec_min(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vminsw(a, (vector int)b);
+  return __builtin_altivec_vminsw(__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_min(vector unsigned int a, vector unsigned int b)
+vec_min(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vminuw(a, b);
+  return __builtin_altivec_vminuw(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_min(vector bool int a, vector unsigned int b)
+vec_min(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vminuw((vector unsigned int)a, b);
+  return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_min(vector unsigned int a, vector bool int b)
+vec_min(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vminuw(a, (vector unsigned int)b);
+  return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
 }
 
 static vector float __ATTRS_o_ai
-vec_min(vector float a, vector float b)
+vec_min(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vminfp(a, b);
+  return __builtin_altivec_vminfp(__a, __b);
 }
 
 /* vec_vminsb */
 
 static vector signed char __ATTRS_o_ai
-vec_vminsb(vector signed char a, vector signed char b)
+vec_vminsb(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vminsb(a, b);
+  return __builtin_altivec_vminsb(__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vminsb(vector bool char a, vector signed char b)
+vec_vminsb(vector bool char __a, vector signed char __b)
 {
-  return __builtin_altivec_vminsb((vector signed char)a, b);
+  return __builtin_altivec_vminsb((vector signed char)__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vminsb(vector signed char a, vector bool char b)
+vec_vminsb(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vminsb(a, (vector signed char)b);
+  return __builtin_altivec_vminsb(__a, (vector signed char)__b);
 }
 
 /* vec_vminub */
 
 static vector unsigned char __ATTRS_o_ai
-vec_vminub(vector unsigned char a, vector unsigned char b)
+vec_vminub(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vminub(a, b);
+  return __builtin_altivec_vminub(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vminub(vector bool char a, vector unsigned char b)
+vec_vminub(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vminub((vector unsigned char)a, b);
+  return __builtin_altivec_vminub((vector unsigned char)__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vminub(vector unsigned char a, vector bool char b)
+vec_vminub(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vminub(a, (vector unsigned char)b);
+  return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
 }
 
 /* vec_vminsh */
 
 static vector short __ATTRS_o_ai
-vec_vminsh(vector short a, vector short b)
+vec_vminsh(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vminsh(a, b);
+  return __builtin_altivec_vminsh(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vminsh(vector bool short a, vector short b)
+vec_vminsh(vector bool short __a, vector short __b)
 {
-  return __builtin_altivec_vminsh((vector short)a, b);
+  return __builtin_altivec_vminsh((vector short)__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vminsh(vector short a, vector bool short b)
+vec_vminsh(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vminsh(a, (vector short)b);
+  return __builtin_altivec_vminsh(__a, (vector short)__b);
 }
 
 /* vec_vminuh */
 
 static vector unsigned short __ATTRS_o_ai
-vec_vminuh(vector unsigned short a, vector unsigned short b)
+vec_vminuh(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vminuh(a, b);
+  return __builtin_altivec_vminuh(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vminuh(vector bool short a, vector unsigned short b)
+vec_vminuh(vector bool short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vminuh((vector unsigned short)a, b);
+  return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vminuh(vector unsigned short a, vector bool short b)
+vec_vminuh(vector unsigned short __a, vector bool short __b)
 {
-  return __builtin_altivec_vminuh(a, (vector unsigned short)b);
+  return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
 }
 
 /* vec_vminsw */
 
 static vector int __ATTRS_o_ai
-vec_vminsw(vector int a, vector int b)
+vec_vminsw(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vminsw(a, b);
+  return __builtin_altivec_vminsw(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vminsw(vector bool int a, vector int b)
+vec_vminsw(vector bool int __a, vector int __b)
 {
-  return __builtin_altivec_vminsw((vector int)a, b);
+  return __builtin_altivec_vminsw((vector int)__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vminsw(vector int a, vector bool int b)
+vec_vminsw(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vminsw(a, (vector int)b);
+  return __builtin_altivec_vminsw(__a, (vector int)__b);
 }
 
 /* vec_vminuw */
 
 static vector unsigned int __ATTRS_o_ai
-vec_vminuw(vector unsigned int a, vector unsigned int b)
+vec_vminuw(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vminuw(a, b);
+  return __builtin_altivec_vminuw(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vminuw(vector bool int a, vector unsigned int b)
+vec_vminuw(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vminuw((vector unsigned int)a, b);
+  return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vminuw(vector unsigned int a, vector bool int b)
+vec_vminuw(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vminuw(a, (vector unsigned int)b);
+  return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
 }
 
 /* vec_vminfp */
 
 static vector float __attribute__((__always_inline__))
-vec_vminfp(vector float a, vector float b)
+vec_vminfp(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vminfp(a, b);
+  return __builtin_altivec_vminfp(__a, __b);
 }
 
 /* vec_mladd */
@@ -3250,371 +3250,371 @@
 #define __builtin_altivec_vmladduhm vec_mladd
 
 static vector short __ATTRS_o_ai
-vec_mladd(vector short a, vector short b, vector short c)
+vec_mladd(vector short __a, vector short __b, vector short __c)
 {
-  return a * b + c;
+  return __a * __b + __c;
 }
 
 static vector short __ATTRS_o_ai
-vec_mladd(vector short a, vector unsigned short b, vector unsigned short c)
+vec_mladd(vector short __a, vector unsigned short __b, vector unsigned short __c)
 {
-  return a * (vector short)b + (vector short)c;
+  return __a * (vector short)__b + (vector short)__c;
 }
 
 static vector short __ATTRS_o_ai
-vec_mladd(vector unsigned short a, vector short b, vector short c)
+vec_mladd(vector unsigned short __a, vector short __b, vector short __c)
 {
-  return (vector short)a * b + c;
+  return (vector short)__a * __b + __c;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_mladd(vector unsigned short a,
-          vector unsigned short b, 
-          vector unsigned short c)
+vec_mladd(vector unsigned short __a,
+          vector unsigned short __b,
+          vector unsigned short __c)
 {
-  return a * b + c;
+  return __a * __b + __c;
 }
 
 /* vec_vmladduhm */
 
 static vector short __ATTRS_o_ai
-vec_vmladduhm(vector short a, vector short b, vector short c)
+vec_vmladduhm(vector short __a, vector short __b, vector short __c)
 {
-  return a * b + c;
+  return __a * __b + __c;
 }
 
 static vector short __ATTRS_o_ai
-vec_vmladduhm(vector short a, vector unsigned short b, vector unsigned short c)
+vec_vmladduhm(vector short __a, vector unsigned short __b, vector unsigned short __c)
 {
-  return a * (vector short)b + (vector short)c;
+  return __a * (vector short)__b + (vector short)__c;
 }
 
 static vector short __ATTRS_o_ai
-vec_vmladduhm(vector unsigned short a, vector short b, vector short c)
+vec_vmladduhm(vector unsigned short __a, vector short __b, vector short __c)
 {
-  return (vector short)a * b + c;
+  return (vector short)__a * __b + __c;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vmladduhm(vector unsigned short a,
-              vector unsigned short b,
-              vector unsigned short c)
+vec_vmladduhm(vector unsigned short __a,
+              vector unsigned short __b,
+              vector unsigned short __c)
 {
-  return a * b + c;
+  return __a * __b + __c;
 }
 
 /* vec_mradds */
 
 static vector short __attribute__((__always_inline__))
-vec_mradds(vector short a, vector short b, vector short c)
+vec_mradds(vector short __a, vector short __b, vector short __c)
 {
-  return __builtin_altivec_vmhraddshs(a, b, c);
+  return __builtin_altivec_vmhraddshs(__a, __b, __c);
 }
 
 /* vec_vmhraddshs */
 
 static vector short __attribute__((__always_inline__))
-vec_vmhraddshs(vector short a, vector short b, vector short c)
+vec_vmhraddshs(vector short __a, vector short __b, vector short __c)
 {
-  return __builtin_altivec_vmhraddshs(a, b, c);
+  return __builtin_altivec_vmhraddshs(__a, __b, __c);
 }
 
 /* vec_msum */
 
 static vector int __ATTRS_o_ai
-vec_msum(vector signed char a, vector unsigned char b, vector int c)
+vec_msum(vector signed char __a, vector unsigned char __b, vector int __c)
 {
-  return __builtin_altivec_vmsummbm(a, b, c);
+  return __builtin_altivec_vmsummbm(__a, __b, __c);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_msum(vector unsigned char a, vector unsigned char b, vector unsigned int c)
+vec_msum(vector unsigned char __a, vector unsigned char __b, vector unsigned int __c)
 {
-  return __builtin_altivec_vmsumubm(a, b, c);
+  return __builtin_altivec_vmsumubm(__a, __b, __c);
 }
 
 static vector int __ATTRS_o_ai
-vec_msum(vector short a, vector short b, vector int c)
+vec_msum(vector short __a, vector short __b, vector int __c)
 {
-  return __builtin_altivec_vmsumshm(a, b, c);
+  return __builtin_altivec_vmsumshm(__a, __b, __c);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_msum(vector unsigned short a,
-         vector unsigned short b,
-         vector unsigned int c)
+vec_msum(vector unsigned short __a,
+         vector unsigned short __b,
+         vector unsigned int __c)
 {
-  return __builtin_altivec_vmsumuhm(a, b, c);
+  return __builtin_altivec_vmsumuhm(__a, __b, __c);
 }
 
 /* vec_vmsummbm */
 
 static vector int __attribute__((__always_inline__))
-vec_vmsummbm(vector signed char a, vector unsigned char b, vector int c)
+vec_vmsummbm(vector signed char __a, vector unsigned char __b, vector int __c)
 {
-  return __builtin_altivec_vmsummbm(a, b, c);
+  return __builtin_altivec_vmsummbm(__a, __b, __c);
 }
 
 /* vec_vmsumubm */
 
 static vector unsigned int __attribute__((__always_inline__))
-vec_vmsumubm(vector unsigned char a,
-             vector unsigned char b,
-             vector unsigned int c)
+vec_vmsumubm(vector unsigned char __a,
+             vector unsigned char __b,
+             vector unsigned int __c)
 {
-  return __builtin_altivec_vmsumubm(a, b, c);
+  return __builtin_altivec_vmsumubm(__a, __b, __c);
 }
 
 /* vec_vmsumshm */
 
 static vector int __attribute__((__always_inline__))
-vec_vmsumshm(vector short a, vector short b, vector int c)
+vec_vmsumshm(vector short __a, vector short __b, vector int __c)
 {
-  return __builtin_altivec_vmsumshm(a, b, c);
+  return __builtin_altivec_vmsumshm(__a, __b, __c);
 }
 
 /* vec_vmsumuhm */
 
 static vector unsigned int __attribute__((__always_inline__))
-vec_vmsumuhm(vector unsigned short a,
-             vector unsigned short b,
-             vector unsigned int c)
+vec_vmsumuhm(vector unsigned short __a,
+             vector unsigned short __b,
+             vector unsigned int __c)
 {
-  return __builtin_altivec_vmsumuhm(a, b, c);
+  return __builtin_altivec_vmsumuhm(__a, __b, __c);
 }
 
 /* vec_msums */
 
 static vector int __ATTRS_o_ai
-vec_msums(vector short a, vector short b, vector int c)
+vec_msums(vector short __a, vector short __b, vector int __c)
 {
-  return __builtin_altivec_vmsumshs(a, b, c);
+  return __builtin_altivec_vmsumshs(__a, __b, __c);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_msums(vector unsigned short a,
-          vector unsigned short b,
-          vector unsigned int c)
+vec_msums(vector unsigned short __a,
+          vector unsigned short __b,
+          vector unsigned int __c)
 {
-  return __builtin_altivec_vmsumuhs(a, b, c);
+  return __builtin_altivec_vmsumuhs(__a, __b, __c);
 }
 
 /* vec_vmsumshs */
 
 static vector int __attribute__((__always_inline__))
-vec_vmsumshs(vector short a, vector short b, vector int c)
+vec_vmsumshs(vector short __a, vector short __b, vector int __c)
 {
-  return __builtin_altivec_vmsumshs(a, b, c);
+  return __builtin_altivec_vmsumshs(__a, __b, __c);
 }
 
 /* vec_vmsumuhs */
 
 static vector unsigned int __attribute__((__always_inline__))
-vec_vmsumuhs(vector unsigned short a,
-             vector unsigned short b,
-             vector unsigned int c)
+vec_vmsumuhs(vector unsigned short __a,
+             vector unsigned short __b,
+             vector unsigned int __c)
 {
-  return __builtin_altivec_vmsumuhs(a, b, c);
+  return __builtin_altivec_vmsumuhs(__a, __b, __c);
 }
 
 /* vec_mtvscr */
 
 static void __ATTRS_o_ai
-vec_mtvscr(vector signed char a)
+vec_mtvscr(vector signed char __a)
 {
-  __builtin_altivec_mtvscr((vector int)a);
+  __builtin_altivec_mtvscr((vector int)__a);
 }
 
 static void __ATTRS_o_ai
-vec_mtvscr(vector unsigned char a)
+vec_mtvscr(vector unsigned char __a)
 {
-  __builtin_altivec_mtvscr((vector int)a);
+  __builtin_altivec_mtvscr((vector int)__a);
 }
 
 static void __ATTRS_o_ai
-vec_mtvscr(vector bool char a)
+vec_mtvscr(vector bool char __a)
 {
-  __builtin_altivec_mtvscr((vector int)a);
+  __builtin_altivec_mtvscr((vector int)__a);
 }
 
 static void __ATTRS_o_ai
-vec_mtvscr(vector short a)
+vec_mtvscr(vector short __a)
 {
-  __builtin_altivec_mtvscr((vector int)a);
+  __builtin_altivec_mtvscr((vector int)__a);
 }
 
 static void __ATTRS_o_ai
-vec_mtvscr(vector unsigned short a)
+vec_mtvscr(vector unsigned short __a)
 {
-  __builtin_altivec_mtvscr((vector int)a);
+  __builtin_altivec_mtvscr((vector int)__a);
 }
 
 static void __ATTRS_o_ai
-vec_mtvscr(vector bool short a)
+vec_mtvscr(vector bool short __a)
 {
-  __builtin_altivec_mtvscr((vector int)a);
+  __builtin_altivec_mtvscr((vector int)__a);
 }
 
 static void __ATTRS_o_ai
-vec_mtvscr(vector pixel a)
+vec_mtvscr(vector pixel __a)
 {
-  __builtin_altivec_mtvscr((vector int)a);
+  __builtin_altivec_mtvscr((vector int)__a);
 }
 
 static void __ATTRS_o_ai
-vec_mtvscr(vector int a)
+vec_mtvscr(vector int __a)
 {
-  __builtin_altivec_mtvscr((vector int)a);
+  __builtin_altivec_mtvscr((vector int)__a);
 }
 
 static void __ATTRS_o_ai
-vec_mtvscr(vector unsigned int a)
+vec_mtvscr(vector unsigned int __a)
 {
-  __builtin_altivec_mtvscr((vector int)a);
+  __builtin_altivec_mtvscr((vector int)__a);
 }
 
 static void __ATTRS_o_ai
-vec_mtvscr(vector bool int a)
+vec_mtvscr(vector bool int __a)
 {
-  __builtin_altivec_mtvscr((vector int)a);
+  __builtin_altivec_mtvscr((vector int)__a);
 }
 
 static void __ATTRS_o_ai
-vec_mtvscr(vector float a)
+vec_mtvscr(vector float __a)
 {
-  __builtin_altivec_mtvscr((vector int)a);
+  __builtin_altivec_mtvscr((vector int)__a);
 }
 
 /* vec_mule */
 
 static vector short __ATTRS_o_ai
-vec_mule(vector signed char a, vector signed char b)
+vec_mule(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vmulesb(a, b);
+  return __builtin_altivec_vmulesb(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_mule(vector unsigned char a, vector unsigned char b)
+vec_mule(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vmuleub(a, b);
+  return __builtin_altivec_vmuleub(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_mule(vector short a, vector short b)
+vec_mule(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vmulesh(a, b);
+  return __builtin_altivec_vmulesh(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_mule(vector unsigned short a, vector unsigned short b)
+vec_mule(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vmuleuh(a, b);
+  return __builtin_altivec_vmuleuh(__a, __b);
 }
 
 /* vec_vmulesb */
 
 static vector short __attribute__((__always_inline__))
-vec_vmulesb(vector signed char a, vector signed char b)
+vec_vmulesb(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vmulesb(a, b);
+  return __builtin_altivec_vmulesb(__a, __b);
 }
 
 /* vec_vmuleub */
 
 static vector unsigned short __attribute__((__always_inline__))
-vec_vmuleub(vector unsigned char a, vector unsigned char b)
+vec_vmuleub(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vmuleub(a, b);
+  return __builtin_altivec_vmuleub(__a, __b);
 }
 
 /* vec_vmulesh */
 
 static vector int __attribute__((__always_inline__))
-vec_vmulesh(vector short a, vector short b)
+vec_vmulesh(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vmulesh(a, b);
+  return __builtin_altivec_vmulesh(__a, __b);
 }
 
 /* vec_vmuleuh */
 
 static vector unsigned int __attribute__((__always_inline__))
-vec_vmuleuh(vector unsigned short a, vector unsigned short b)
+vec_vmuleuh(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vmuleuh(a, b);
+  return __builtin_altivec_vmuleuh(__a, __b);
 }
 
 /* vec_mulo */
 
 static vector short __ATTRS_o_ai
-vec_mulo(vector signed char a, vector signed char b)
+vec_mulo(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vmulosb(a, b);
+  return __builtin_altivec_vmulosb(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_mulo(vector unsigned char a, vector unsigned char b)
+vec_mulo(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vmuloub(a, b);
+  return __builtin_altivec_vmuloub(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_mulo(vector short a, vector short b)
+vec_mulo(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vmulosh(a, b);
+  return __builtin_altivec_vmulosh(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_mulo(vector unsigned short a, vector unsigned short b)
+vec_mulo(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vmulouh(a, b);
+  return __builtin_altivec_vmulouh(__a, __b);
 }
 
 /* vec_vmulosb */
 
 static vector short __attribute__((__always_inline__))
-vec_vmulosb(vector signed char a, vector signed char b)
+vec_vmulosb(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vmulosb(a, b);
+  return __builtin_altivec_vmulosb(__a, __b);
 }
 
 /* vec_vmuloub */
 
 static vector unsigned short __attribute__((__always_inline__))
-vec_vmuloub(vector unsigned char a, vector unsigned char b)
+vec_vmuloub(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vmuloub(a, b);
+  return __builtin_altivec_vmuloub(__a, __b);
 }
 
 /* vec_vmulosh */
 
 static vector int __attribute__((__always_inline__))
-vec_vmulosh(vector short a, vector short b)
+vec_vmulosh(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vmulosh(a, b);
+  return __builtin_altivec_vmulosh(__a, __b);
 }
 
 /* vec_vmulouh */
 
 static vector unsigned int __attribute__((__always_inline__))
-vec_vmulouh(vector unsigned short a, vector unsigned short b)
+vec_vmulouh(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vmulouh(a, b);
+  return __builtin_altivec_vmulouh(__a, __b);
 }
 
 /* vec_nmsub */
 
 static vector float __attribute__((__always_inline__))
-vec_nmsub(vector float a, vector float b, vector float c)
+vec_nmsub(vector float __a, vector float __b, vector float __c)
 {
-  return __builtin_altivec_vnmsubfp(a, b, c);
+  return __builtin_altivec_vnmsubfp(__a, __b, __c);
 }
 
 /* vec_vnmsubfp */
 
 static vector float __attribute__((__always_inline__))
-vec_vnmsubfp(vector float a, vector float b, vector float c)
+vec_vnmsubfp(vector float __a, vector float __b, vector float __c)
 {
-  return __builtin_altivec_vnmsubfp(a, b, c);
+  return __builtin_altivec_vnmsubfp(__a, __b, __c);
 }
 
 /* vec_nor */
@@ -3622,127 +3622,127 @@
 #define __builtin_altivec_vnor vec_nor
 
 static vector signed char __ATTRS_o_ai
-vec_nor(vector signed char a, vector signed char b)
+vec_nor(vector signed char __a, vector signed char __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_nor(vector unsigned char a, vector unsigned char b)
+vec_nor(vector unsigned char __a, vector unsigned char __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_nor(vector bool char a, vector bool char b)
+vec_nor(vector bool char __a, vector bool char __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_nor(vector short a, vector short b)
+vec_nor(vector short __a, vector short __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_nor(vector unsigned short a, vector unsigned short b)
+vec_nor(vector unsigned short __a, vector unsigned short __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_nor(vector bool short a, vector bool short b)
+vec_nor(vector bool short __a, vector bool short __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_nor(vector int a, vector int b)
+vec_nor(vector int __a, vector int __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_nor(vector unsigned int a, vector unsigned int b)
+vec_nor(vector unsigned int __a, vector unsigned int __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_nor(vector bool int a, vector bool int b)
+vec_nor(vector bool int __a, vector bool int __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector float __ATTRS_o_ai
-vec_nor(vector float a, vector float b)
+vec_nor(vector float __a, vector float __b)
 {
-  vector unsigned int res = ~((vector unsigned int)a | (vector unsigned int)b);
-  return (vector float)res;
+  vector unsigned int __res = ~((vector unsigned int)__a | (vector unsigned int)__b);
+  return (vector float)__res;
 }
 
 /* vec_vnor */
 
 static vector signed char __ATTRS_o_ai
-vec_vnor(vector signed char a, vector signed char b)
+vec_vnor(vector signed char __a, vector signed char __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vnor(vector unsigned char a, vector unsigned char b)
+vec_vnor(vector unsigned char __a, vector unsigned char __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vnor(vector bool char a, vector bool char b)
+vec_vnor(vector bool char __a, vector bool char __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vnor(vector short a, vector short b)
+vec_vnor(vector short __a, vector short __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vnor(vector unsigned short a, vector unsigned short b)
+vec_vnor(vector unsigned short __a, vector unsigned short __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vnor(vector bool short a, vector bool short b)
+vec_vnor(vector bool short __a, vector bool short __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vnor(vector int a, vector int b)
+vec_vnor(vector int __a, vector int __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vnor(vector unsigned int a, vector unsigned int b)
+vec_vnor(vector unsigned int __a, vector unsigned int __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vnor(vector bool int a, vector bool int b)
+vec_vnor(vector bool int __a, vector bool int __b)
 {
-  return ~(a | b);
+  return ~(__a | __b);
 }
 
 static vector float __ATTRS_o_ai
-vec_vnor(vector float a, vector float b)
+vec_vnor(vector float __a, vector float __b)
 {
-  vector unsigned int res = ~((vector unsigned int)a | (vector unsigned int)b);
-  return (vector float)res;
+  vector unsigned int __res = ~((vector unsigned int)__a | (vector unsigned int)__b);
+  return (vector float)__res;
 }
 
 /* vec_or */
@@ -3750,347 +3750,347 @@
 #define __builtin_altivec_vor vec_or
 
 static vector signed char __ATTRS_o_ai
-vec_or(vector signed char a, vector signed char b)
+vec_or(vector signed char __a, vector signed char __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_or(vector bool char a, vector signed char b)
+vec_or(vector bool char __a, vector signed char __b)
 {
-  return (vector signed char)a | b;
+  return (vector signed char)__a | __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_or(vector signed char a, vector bool char b)
+vec_or(vector signed char __a, vector bool char __b)
 {
-  return a | (vector signed char)b;
+  return __a | (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_or(vector unsigned char a, vector unsigned char b)
+vec_or(vector unsigned char __a, vector unsigned char __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_or(vector bool char a, vector unsigned char b)
+vec_or(vector bool char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)a | b;
+  return (vector unsigned char)__a | __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_or(vector unsigned char a, vector bool char b)
+vec_or(vector unsigned char __a, vector bool char __b)
 {
-  return a | (vector unsigned char)b;
+  return __a | (vector unsigned char)__b;
 }
 
 static vector bool char __ATTRS_o_ai
-vec_or(vector bool char a, vector bool char b)
+vec_or(vector bool char __a, vector bool char __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_or(vector short a, vector short b)
+vec_or(vector short __a, vector short __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_or(vector bool short a, vector short b)
+vec_or(vector bool short __a, vector short __b)
 {
-  return (vector short)a | b;
+  return (vector short)__a | __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_or(vector short a, vector bool short b)
+vec_or(vector short __a, vector bool short __b)
 {
-  return a | (vector short)b;
+  return __a | (vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_or(vector unsigned short a, vector unsigned short b)
+vec_or(vector unsigned short __a, vector unsigned short __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_or(vector bool short a, vector unsigned short b)
+vec_or(vector bool short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)a | b;
+  return (vector unsigned short)__a | __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_or(vector unsigned short a, vector bool short b)
+vec_or(vector unsigned short __a, vector bool short __b)
 {
-  return a | (vector unsigned short)b;
+  return __a | (vector unsigned short)__b;
 }
 
 static vector bool short __ATTRS_o_ai
-vec_or(vector bool short a, vector bool short b)
+vec_or(vector bool short __a, vector bool short __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_or(vector int a, vector int b)
+vec_or(vector int __a, vector int __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_or(vector bool int a, vector int b)
+vec_or(vector bool int __a, vector int __b)
 {
-  return (vector int)a | b;
+  return (vector int)__a | __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_or(vector int a, vector bool int b)
+vec_or(vector int __a, vector bool int __b)
 {
-  return a | (vector int)b;
+  return __a | (vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_or(vector unsigned int a, vector unsigned int b)
+vec_or(vector unsigned int __a, vector unsigned int __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_or(vector bool int a, vector unsigned int b)
+vec_or(vector bool int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)a | b;
+  return (vector unsigned int)__a | __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_or(vector unsigned int a, vector bool int b)
+vec_or(vector unsigned int __a, vector bool int __b)
 {
-  return a | (vector unsigned int)b;
+  return __a | (vector unsigned int)__b;
 }
 
 static vector bool int __ATTRS_o_ai
-vec_or(vector bool int a, vector bool int b)
+vec_or(vector bool int __a, vector bool int __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector float __ATTRS_o_ai
-vec_or(vector float a, vector float b)
+vec_or(vector float __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a | (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a | (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_or(vector bool int a, vector float b)
+vec_or(vector bool int __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a | (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a | (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_or(vector float a, vector bool int b)
+vec_or(vector float __a, vector bool int __b)
 {
-  vector unsigned int res = (vector unsigned int)a | (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a | (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 /* vec_vor */
 
 static vector signed char __ATTRS_o_ai
-vec_vor(vector signed char a, vector signed char b)
+vec_vor(vector signed char __a, vector signed char __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vor(vector bool char a, vector signed char b)
+vec_vor(vector bool char __a, vector signed char __b)
 {
-  return (vector signed char)a | b;
+  return (vector signed char)__a | __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vor(vector signed char a, vector bool char b)
+vec_vor(vector signed char __a, vector bool char __b)
 {
-  return a | (vector signed char)b;
+  return __a | (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vor(vector unsigned char a, vector unsigned char b)
+vec_vor(vector unsigned char __a, vector unsigned char __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vor(vector bool char a, vector unsigned char b)
+vec_vor(vector bool char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)a | b;
+  return (vector unsigned char)__a | __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vor(vector unsigned char a, vector bool char b)
+vec_vor(vector unsigned char __a, vector bool char __b)
 {
-  return a | (vector unsigned char)b;
+  return __a | (vector unsigned char)__b;
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vor(vector bool char a, vector bool char b)
+vec_vor(vector bool char __a, vector bool char __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vor(vector short a, vector short b)
+vec_vor(vector short __a, vector short __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vor(vector bool short a, vector short b)
+vec_vor(vector bool short __a, vector short __b)
 {
-  return (vector short)a | b;
+  return (vector short)__a | __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vor(vector short a, vector bool short b)
+vec_vor(vector short __a, vector bool short __b)
 {
-  return a | (vector short)b;
+  return __a | (vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vor(vector unsigned short a, vector unsigned short b)
+vec_vor(vector unsigned short __a, vector unsigned short __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vor(vector bool short a, vector unsigned short b)
+vec_vor(vector bool short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)a | b;
+  return (vector unsigned short)__a | __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vor(vector unsigned short a, vector bool short b)
+vec_vor(vector unsigned short __a, vector bool short __b)
 {
-  return a | (vector unsigned short)b;
+  return __a | (vector unsigned short)__b;
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vor(vector bool short a, vector bool short b)
+vec_vor(vector bool short __a, vector bool short __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vor(vector int a, vector int b)
+vec_vor(vector int __a, vector int __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vor(vector bool int a, vector int b)
+vec_vor(vector bool int __a, vector int __b)
 {
-  return (vector int)a | b;
+  return (vector int)__a | __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vor(vector int a, vector bool int b)
+vec_vor(vector int __a, vector bool int __b)
 {
-  return a | (vector int)b;
+  return __a | (vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vor(vector unsigned int a, vector unsigned int b)
+vec_vor(vector unsigned int __a, vector unsigned int __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vor(vector bool int a, vector unsigned int b)
+vec_vor(vector bool int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)a | b;
+  return (vector unsigned int)__a | __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vor(vector unsigned int a, vector bool int b)
+vec_vor(vector unsigned int __a, vector bool int __b)
 {
-  return a | (vector unsigned int)b;
+  return __a | (vector unsigned int)__b;
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vor(vector bool int a, vector bool int b)
+vec_vor(vector bool int __a, vector bool int __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static vector float __ATTRS_o_ai
-vec_vor(vector float a, vector float b)
+vec_vor(vector float __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a | (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a | (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_vor(vector bool int a, vector float b)
+vec_vor(vector bool int __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a | (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a | (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_vor(vector float a, vector bool int b)
+vec_vor(vector float __a, vector bool int __b)
 {
-  vector unsigned int res = (vector unsigned int)a | (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a | (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 /* vec_pack */
 
 static vector signed char __ATTRS_o_ai
-vec_pack(vector signed short a, vector signed short b)
+vec_pack(vector signed short __a, vector signed short __b)
 {
-  return (vector signed char)vec_perm(a, b, (vector unsigned char)
+  return (vector signed char)vec_perm(__a, __b, (vector unsigned char)
     (0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
      0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_pack(vector unsigned short a, vector unsigned short b)
+vec_pack(vector unsigned short __a, vector unsigned short __b)
 {
-  return (vector unsigned char)vec_perm(a, b, (vector unsigned char)
+  return (vector unsigned char)vec_perm(__a, __b, (vector unsigned char)
     (0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
      0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
 }
 
 static vector bool char __ATTRS_o_ai
-vec_pack(vector bool short a, vector bool short b)
+vec_pack(vector bool short __a, vector bool short __b)
 {
-  return (vector bool char)vec_perm(a, b, (vector unsigned char)
+  return (vector bool char)vec_perm(__a, __b, (vector unsigned char)
     (0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
      0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
 }
 
 static vector short __ATTRS_o_ai
-vec_pack(vector int a, vector int b)
+vec_pack(vector int __a, vector int __b)
 {
-  return (vector short)vec_perm(a, b, (vector unsigned char)
+  return (vector short)vec_perm(__a, __b, (vector unsigned char)
     (0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
      0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_pack(vector unsigned int a, vector unsigned int b)
+vec_pack(vector unsigned int __a, vector unsigned int __b)
 {
-  return (vector unsigned short)vec_perm(a, b, (vector unsigned char)
+  return (vector unsigned short)vec_perm(__a, __b, (vector unsigned char)
     (0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
      0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
 }
 
 static vector bool short __ATTRS_o_ai
-vec_pack(vector bool int a, vector bool int b)
+vec_pack(vector bool int __a, vector bool int __b)
 {
-  return (vector bool short)vec_perm(a, b, (vector unsigned char)
+  return (vector bool short)vec_perm(__a, __b, (vector unsigned char)
     (0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
      0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
 }
@@ -4100,25 +4100,25 @@
 #define __builtin_altivec_vpkuhum vec_vpkuhum
 
 static vector signed char __ATTRS_o_ai
-vec_vpkuhum(vector signed short a, vector signed short b)
+vec_vpkuhum(vector signed short __a, vector signed short __b)
 {
-  return (vector signed char)vec_perm(a, b, (vector unsigned char)
+  return (vector signed char)vec_perm(__a, __b, (vector unsigned char)
     (0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
      0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vpkuhum(vector unsigned short a, vector unsigned short b)
+vec_vpkuhum(vector unsigned short __a, vector unsigned short __b)
 {
-  return (vector unsigned char)vec_perm(a, b, (vector unsigned char)
+  return (vector unsigned char)vec_perm(__a, __b, (vector unsigned char)
     (0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
      0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vpkuhum(vector bool short a, vector bool short b)
+vec_vpkuhum(vector bool short __a, vector bool short __b)
 {
-  return (vector bool char)vec_perm(a, b, (vector unsigned char)
+  return (vector bool char)vec_perm(__a, __b, (vector unsigned char)
     (0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
      0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
 }
@@ -4128,25 +4128,25 @@
 #define __builtin_altivec_vpkuwum vec_vpkuwum
 
 static vector short __ATTRS_o_ai
-vec_vpkuwum(vector int a, vector int b)
+vec_vpkuwum(vector int __a, vector int __b)
 {
-  return (vector short)vec_perm(a, b, (vector unsigned char)
+  return (vector short)vec_perm(__a, __b, (vector unsigned char)
     (0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
      0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vpkuwum(vector unsigned int a, vector unsigned int b)
+vec_vpkuwum(vector unsigned int __a, vector unsigned int __b)
 {
-  return (vector unsigned short)vec_perm(a, b, (vector unsigned char)
+  return (vector unsigned short)vec_perm(__a, __b, (vector unsigned char)
     (0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
      0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vpkuwum(vector bool int a, vector bool int b)
+vec_vpkuwum(vector bool int __a, vector bool int __b)
 {
-  return (vector bool short)vec_perm(a, b, (vector unsigned char)
+  return (vector bool short)vec_perm(__a, __b, (vector unsigned char)
     (0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
      0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
 }
@@ -4154,421 +4154,421 @@
 /* vec_packpx */
 
 static vector pixel __attribute__((__always_inline__))
-vec_packpx(vector unsigned int a, vector unsigned int b)
+vec_packpx(vector unsigned int __a, vector unsigned int __b)
 {
-  return (vector pixel)__builtin_altivec_vpkpx(a, b);
+  return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
 }
 
 /* vec_vpkpx */
 
 static vector pixel __attribute__((__always_inline__))
-vec_vpkpx(vector unsigned int a, vector unsigned int b)
+vec_vpkpx(vector unsigned int __a, vector unsigned int __b)
 {
-  return (vector pixel)__builtin_altivec_vpkpx(a, b);
+  return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
 }
 
 /* vec_packs */
 
 static vector signed char __ATTRS_o_ai
-vec_packs(vector short a, vector short b)
+vec_packs(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vpkshss(a, b);
+  return __builtin_altivec_vpkshss(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_packs(vector unsigned short a, vector unsigned short b)
+vec_packs(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vpkuhus(a, b);
+  return __builtin_altivec_vpkuhus(__a, __b);
 }
 
 static vector signed short __ATTRS_o_ai
-vec_packs(vector int a, vector int b)
+vec_packs(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vpkswss(a, b);
+  return __builtin_altivec_vpkswss(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_packs(vector unsigned int a, vector unsigned int b)
+vec_packs(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vpkuwus(a, b);
+  return __builtin_altivec_vpkuwus(__a, __b);
 }
 
 /* vec_vpkshss */
 
 static vector signed char __attribute__((__always_inline__))
-vec_vpkshss(vector short a, vector short b)
+vec_vpkshss(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vpkshss(a, b);
+  return __builtin_altivec_vpkshss(__a, __b);
 }
 
 /* vec_vpkuhus */
 
 static vector unsigned char __attribute__((__always_inline__))
-vec_vpkuhus(vector unsigned short a, vector unsigned short b)
+vec_vpkuhus(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vpkuhus(a, b);
+  return __builtin_altivec_vpkuhus(__a, __b);
 }
 
 /* vec_vpkswss */
 
 static vector signed short __attribute__((__always_inline__))
-vec_vpkswss(vector int a, vector int b)
+vec_vpkswss(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vpkswss(a, b);
+  return __builtin_altivec_vpkswss(__a, __b);
 }
 
 /* vec_vpkuwus */
 
 static vector unsigned short __attribute__((__always_inline__))
-vec_vpkuwus(vector unsigned int a, vector unsigned int b)
+vec_vpkuwus(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vpkuwus(a, b);
+  return __builtin_altivec_vpkuwus(__a, __b);
 }
 
 /* vec_packsu */
 
 static vector unsigned char __ATTRS_o_ai
-vec_packsu(vector short a, vector short b)
+vec_packsu(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vpkshus(a, b);
+  return __builtin_altivec_vpkshus(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_packsu(vector unsigned short a, vector unsigned short b)
+vec_packsu(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vpkuhus(a, b);
+  return __builtin_altivec_vpkuhus(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_packsu(vector int a, vector int b)
+vec_packsu(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vpkswus(a, b);
+  return __builtin_altivec_vpkswus(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_packsu(vector unsigned int a, vector unsigned int b)
+vec_packsu(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vpkuwus(a, b);
+  return __builtin_altivec_vpkuwus(__a, __b);
 }
 
 /* vec_vpkshus */
 
 static vector unsigned char __ATTRS_o_ai
-vec_vpkshus(vector short a, vector short b)
+vec_vpkshus(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vpkshus(a, b);
+  return __builtin_altivec_vpkshus(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vpkshus(vector unsigned short a, vector unsigned short b)
+vec_vpkshus(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vpkuhus(a, b);
+  return __builtin_altivec_vpkuhus(__a, __b);
 }
 
 /* vec_vpkswus */
 
 static vector unsigned short __ATTRS_o_ai
-vec_vpkswus(vector int a, vector int b)
+vec_vpkswus(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vpkswus(a, b);
+  return __builtin_altivec_vpkswus(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vpkswus(vector unsigned int a, vector unsigned int b)
+vec_vpkswus(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vpkuwus(a, b);
+  return __builtin_altivec_vpkuwus(__a, __b);
 }
 
 /* vec_perm */
 
 vector signed char __ATTRS_o_ai
-vec_perm(vector signed char a, vector signed char b, vector unsigned char c)
+vec_perm(vector signed char __a, vector signed char __b, vector unsigned char __c)
 {
   return (vector signed char)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
 vector unsigned char __ATTRS_o_ai
-vec_perm(vector unsigned char a,
-         vector unsigned char b,
-         vector unsigned char c)
+vec_perm(vector unsigned char __a,
+         vector unsigned char __b,
+         vector unsigned char __c)
 {
   return (vector unsigned char)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
 vector bool char __ATTRS_o_ai
-vec_perm(vector bool char a, vector bool char b, vector unsigned char c)
+vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c)
 {
   return (vector bool char)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
 vector short __ATTRS_o_ai
-vec_perm(vector short a, vector short b, vector unsigned char c)
+vec_perm(vector short __a, vector short __b, vector unsigned char __c)
 {
   return (vector short)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
 vector unsigned short __ATTRS_o_ai
-vec_perm(vector unsigned short a,
-         vector unsigned short b,
-         vector unsigned char c)
+vec_perm(vector unsigned short __a,
+         vector unsigned short __b,
+         vector unsigned char __c)
 {
   return (vector unsigned short)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
 vector bool short __ATTRS_o_ai
-vec_perm(vector bool short a, vector bool short b, vector unsigned char c)
+vec_perm(vector bool short __a, vector bool short __b, vector unsigned char __c)
 {
   return (vector bool short)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
 vector pixel __ATTRS_o_ai
-vec_perm(vector pixel a, vector pixel b, vector unsigned char c)
+vec_perm(vector pixel __a, vector pixel __b, vector unsigned char __c)
 {
   return (vector pixel)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
 vector int __ATTRS_o_ai
-vec_perm(vector int a, vector int b, vector unsigned char c)
+vec_perm(vector int __a, vector int __b, vector unsigned char __c)
 {
-  return (vector int)__builtin_altivec_vperm_4si(a, b, c);
+  return (vector int)__builtin_altivec_vperm_4si(__a, __b, __c);
 }
 
 vector unsigned int __ATTRS_o_ai
-vec_perm(vector unsigned int a, vector unsigned int b, vector unsigned char c)
+vec_perm(vector unsigned int __a, vector unsigned int __b, vector unsigned char __c)
 {
   return (vector unsigned int)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
 vector bool int __ATTRS_o_ai
-vec_perm(vector bool int a, vector bool int b, vector unsigned char c)
+vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c)
 {
   return (vector bool int)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
 vector float __ATTRS_o_ai
-vec_perm(vector float a, vector float b, vector unsigned char c)
+vec_perm(vector float __a, vector float __b, vector unsigned char __c)
 {
   return (vector float)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
 /* vec_vperm */
 
-vector signed char __ATTRS_o_ai
-vec_vperm(vector signed char a, vector signed char b, vector unsigned char c)
+static vector signed char __ATTRS_o_ai
+vec_vperm(vector signed char __a, vector signed char __b, vector unsigned char __c)
 {
   return (vector signed char)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
-vector unsigned char __ATTRS_o_ai
-vec_vperm(vector unsigned char a,
-          vector unsigned char b,
-          vector unsigned char c)
+static vector unsigned char __ATTRS_o_ai
+vec_vperm(vector unsigned char __a,
+          vector unsigned char __b,
+          vector unsigned char __c)
 {
   return (vector unsigned char)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
-vector bool char __ATTRS_o_ai
-vec_vperm(vector bool char a, vector bool char b, vector unsigned char c)
+static vector bool char __ATTRS_o_ai
+vec_vperm(vector bool char __a, vector bool char __b, vector unsigned char __c)
 {
   return (vector bool char)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
-vector short __ATTRS_o_ai
-vec_vperm(vector short a, vector short b, vector unsigned char c)
+static vector short __ATTRS_o_ai
+vec_vperm(vector short __a, vector short __b, vector unsigned char __c)
 {
   return (vector short)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
-vector unsigned short __ATTRS_o_ai
-vec_vperm(vector unsigned short a,
-          vector unsigned short b,
-          vector unsigned char c)
+static vector unsigned short __ATTRS_o_ai
+vec_vperm(vector unsigned short __a,
+          vector unsigned short __b,
+          vector unsigned char __c)
 {
   return (vector unsigned short)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
-vector bool short __ATTRS_o_ai
-vec_vperm(vector bool short a, vector bool short b, vector unsigned char c)
+static vector bool short __ATTRS_o_ai
+vec_vperm(vector bool short __a, vector bool short __b, vector unsigned char __c)
 {
   return (vector bool short)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
-vector pixel __ATTRS_o_ai
-vec_vperm(vector pixel a, vector pixel b, vector unsigned char c)
+static vector pixel __ATTRS_o_ai
+vec_vperm(vector pixel __a, vector pixel __b, vector unsigned char __c)
 {
   return (vector pixel)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
-vector int __ATTRS_o_ai
-vec_vperm(vector int a, vector int b, vector unsigned char c)
+static vector int __ATTRS_o_ai
+vec_vperm(vector int __a, vector int __b, vector unsigned char __c)
 {
-  return (vector int)__builtin_altivec_vperm_4si(a, b, c);
+  return (vector int)__builtin_altivec_vperm_4si(__a, __b, __c);
 }
 
-vector unsigned int __ATTRS_o_ai
-vec_vperm(vector unsigned int a, vector unsigned int b, vector unsigned char c)
+static vector unsigned int __ATTRS_o_ai
+vec_vperm(vector unsigned int __a, vector unsigned int __b, vector unsigned char __c)
 {
   return (vector unsigned int)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
-vector bool int __ATTRS_o_ai
-vec_vperm(vector bool int a, vector bool int b, vector unsigned char c)
+static vector bool int __ATTRS_o_ai
+vec_vperm(vector bool int __a, vector bool int __b, vector unsigned char __c)
 {
   return (vector bool int)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
-vector float __ATTRS_o_ai
-vec_vperm(vector float a, vector float b, vector unsigned char c)
+static vector float __ATTRS_o_ai
+vec_vperm(vector float __a, vector float __b, vector unsigned char __c)
 {
   return (vector float)
-           __builtin_altivec_vperm_4si((vector int)a, (vector int)b, c);
+           __builtin_altivec_vperm_4si((vector int)__a, (vector int)__b, __c);
 }
 
 /* vec_re */
 
-vector float __attribute__((__always_inline__))
-vec_re(vector float a)
+static vector float __attribute__((__always_inline__))
+vec_re(vector float __a)
 {
-  return __builtin_altivec_vrefp(a);
+  return __builtin_altivec_vrefp(__a);
 }
 
 /* vec_vrefp */
 
-vector float __attribute__((__always_inline__))
-vec_vrefp(vector float a)
+static vector float __attribute__((__always_inline__))
+vec_vrefp(vector float __a)
 {
-  return __builtin_altivec_vrefp(a);
+  return __builtin_altivec_vrefp(__a);
 }
 
 /* vec_rl */
 
 static vector signed char __ATTRS_o_ai
-vec_rl(vector signed char a, vector unsigned char b)
+vec_rl(vector signed char __a, vector unsigned char __b)
 {
-  return (vector signed char)__builtin_altivec_vrlb((vector char)a, b);
+  return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_rl(vector unsigned char a, vector unsigned char b)
+vec_rl(vector unsigned char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)__builtin_altivec_vrlb((vector char)a, b);
+  return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_rl(vector short a, vector unsigned short b)
+vec_rl(vector short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vrlh(a, b);
+  return __builtin_altivec_vrlh(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_rl(vector unsigned short a, vector unsigned short b)
+vec_rl(vector unsigned short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)__builtin_altivec_vrlh((vector short)a, b);
+  return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_rl(vector int a, vector unsigned int b)
+vec_rl(vector int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vrlw(a, b);
+  return __builtin_altivec_vrlw(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_rl(vector unsigned int a, vector unsigned int b)
+vec_rl(vector unsigned int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)__builtin_altivec_vrlw((vector int)a, b);
+  return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
 }
 
 /* vec_vrlb */
 
 static vector signed char __ATTRS_o_ai
-vec_vrlb(vector signed char a, vector unsigned char b)
+vec_vrlb(vector signed char __a, vector unsigned char __b)
 {
-  return (vector signed char)__builtin_altivec_vrlb((vector char)a, b);
+  return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vrlb(vector unsigned char a, vector unsigned char b)
+vec_vrlb(vector unsigned char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)__builtin_altivec_vrlb((vector char)a, b);
+  return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
 }
 
 /* vec_vrlh */
 
 static vector short __ATTRS_o_ai
-vec_vrlh(vector short a, vector unsigned short b)
+vec_vrlh(vector short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vrlh(a, b);
+  return __builtin_altivec_vrlh(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vrlh(vector unsigned short a, vector unsigned short b)
+vec_vrlh(vector unsigned short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)__builtin_altivec_vrlh((vector short)a, b);
+  return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
 }
 
 /* vec_vrlw */
 
 static vector int __ATTRS_o_ai
-vec_vrlw(vector int a, vector unsigned int b)
+vec_vrlw(vector int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vrlw(a, b);
+  return __builtin_altivec_vrlw(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vrlw(vector unsigned int a, vector unsigned int b)
+vec_vrlw(vector unsigned int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)__builtin_altivec_vrlw((vector int)a, b);
+  return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
 }
 
 /* vec_round */
 
 static vector float __attribute__((__always_inline__))
-vec_round(vector float a)
+vec_round(vector float __a)
 {
-  return __builtin_altivec_vrfin(a);
+  return __builtin_altivec_vrfin(__a);
 }
 
 /* vec_vrfin */
 
 static vector float __attribute__((__always_inline__))
-vec_vrfin(vector float a)
+vec_vrfin(vector float __a)
 {
-  return __builtin_altivec_vrfin(a);
+  return __builtin_altivec_vrfin(__a);
 }
 
 /* vec_rsqrte */
 
 static __vector float __attribute__((__always_inline__))
-vec_rsqrte(vector float a)
+vec_rsqrte(vector float __a)
 {
-  return __builtin_altivec_vrsqrtefp(a);
+  return __builtin_altivec_vrsqrtefp(__a);
 }
 
 /* vec_vrsqrtefp */
 
 static __vector float __attribute__((__always_inline__))
-vec_vrsqrtefp(vector float a)
+vec_vrsqrtefp(vector float __a)
 {
-  return __builtin_altivec_vrsqrtefp(a);
+  return __builtin_altivec_vrsqrtefp(__a);
 }
 
 /* vec_sel */
@@ -4576,295 +4576,295 @@
 #define __builtin_altivec_vsel_4si vec_sel
 
 static vector signed char __ATTRS_o_ai
-vec_sel(vector signed char a, vector signed char b, vector unsigned char c)
+vec_sel(vector signed char __a, vector signed char __b, vector unsigned char __c)
 {
-  return (a & ~(vector signed char)c) | (b & (vector signed char)c);
+  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_sel(vector signed char a, vector signed char b, vector bool char c)
+vec_sel(vector signed char __a, vector signed char __b, vector bool char __c)
 {
-  return (a & ~(vector signed char)c) | (b & (vector signed char)c);
+  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_sel(vector unsigned char a, vector unsigned char b, vector unsigned char c)
+vec_sel(vector unsigned char __a, vector unsigned char __b, vector unsigned char __c)
 {
-  return (a & ~c) | (b & c);
+  return (__a & ~__c) | (__b & __c);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_sel(vector unsigned char a, vector unsigned char b, vector bool char c)
+vec_sel(vector unsigned char __a, vector unsigned char __b, vector bool char __c)
 {
-  return (a & ~(vector unsigned char)c) | (b & (vector unsigned char)c);
+  return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_sel(vector bool char a, vector bool char b, vector unsigned char c)
+vec_sel(vector bool char __a, vector bool char __b, vector unsigned char __c)
 {
-  return (a & ~(vector bool char)c) | (b & (vector bool char)c);
+  return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_sel(vector bool char a, vector bool char b, vector bool char c)
+vec_sel(vector bool char __a, vector bool char __b, vector bool char __c)
 {
-  return (a & ~c) | (b & c);
+  return (__a & ~__c) | (__b & __c);
 }
 
 static vector short __ATTRS_o_ai
-vec_sel(vector short a, vector short b, vector unsigned short c)
+vec_sel(vector short __a, vector short __b, vector unsigned short __c)
 {
-  return (a & ~(vector short)c) | (b & (vector short)c);
+  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
 }
 
 static vector short __ATTRS_o_ai
-vec_sel(vector short a, vector short b, vector bool short c)
+vec_sel(vector short __a, vector short __b, vector bool short __c)
 {
-  return (a & ~(vector short)c) | (b & (vector short)c);
+  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_sel(vector unsigned short a,
-        vector unsigned short b,
-        vector unsigned short c)
+vec_sel(vector unsigned short __a,
+        vector unsigned short __b,
+        vector unsigned short __c)
 {
-  return (a & ~c) | (b & c);
+  return (__a & ~__c) | (__b & __c);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_sel(vector unsigned short a, vector unsigned short b, vector bool short c)
+vec_sel(vector unsigned short __a, vector unsigned short __b, vector bool short __c)
 {
-  return (a & ~(vector unsigned short)c) | (b & (vector unsigned short)c);
+  return (__a & ~(vector unsigned short)__c) | (__b & (vector unsigned short)__c);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_sel(vector bool short a, vector bool short b, vector unsigned short c)
+vec_sel(vector bool short __a, vector bool short __b, vector unsigned short __c)
 {
-  return (a & ~(vector bool short)c) | (b & (vector bool short)c);
+  return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_sel(vector bool short a, vector bool short b, vector bool short c)
+vec_sel(vector bool short __a, vector bool short __b, vector bool short __c)
 {
-  return (a & ~c) | (b & c);
+  return (__a & ~__c) | (__b & __c);
 }
 
 static vector int __ATTRS_o_ai
-vec_sel(vector int a, vector int b, vector unsigned int c)
+vec_sel(vector int __a, vector int __b, vector unsigned int __c)
 {
-  return (a & ~(vector int)c) | (b & (vector int)c);
+  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
 }
 
 static vector int __ATTRS_o_ai
-vec_sel(vector int a, vector int b, vector bool int c)
+vec_sel(vector int __a, vector int __b, vector bool int __c)
 {
-  return (a & ~(vector int)c) | (b & (vector int)c);
+  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_sel(vector unsigned int a, vector unsigned int b, vector unsigned int c)
+vec_sel(vector unsigned int __a, vector unsigned int __b, vector unsigned int __c)
 {
-  return (a & ~c) | (b & c);
+  return (__a & ~__c) | (__b & __c);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_sel(vector unsigned int a, vector unsigned int b, vector bool int c)
+vec_sel(vector unsigned int __a, vector unsigned int __b, vector bool int __c)
 {
-  return (a & ~(vector unsigned int)c) | (b & (vector unsigned int)c);
+  return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_sel(vector bool int a, vector bool int b, vector unsigned int c)
+vec_sel(vector bool int __a, vector bool int __b, vector unsigned int __c)
 {
-  return (a & ~(vector bool int)c) | (b & (vector bool int)c);
+  return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_sel(vector bool int a, vector bool int b, vector bool int c)
+vec_sel(vector bool int __a, vector bool int __b, vector bool int __c)
 {
-  return (a & ~c) | (b & c);
+  return (__a & ~__c) | (__b & __c);
 }
 
 static vector float __ATTRS_o_ai
-vec_sel(vector float a, vector float b, vector unsigned int c)
+vec_sel(vector float __a, vector float __b, vector unsigned int __c)
 {
-  vector int res = ((vector int)a & ~(vector int)c) 
-                   | ((vector int)b & (vector int)c);
-  return (vector float)res;
+  vector int __res = ((vector int)__a & ~(vector int)__c)
+                   | ((vector int)__b & (vector int)__c);
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_sel(vector float a, vector float b, vector bool int c)
+vec_sel(vector float __a, vector float __b, vector bool int __c)
 {
-  vector int res = ((vector int)a & ~(vector int)c)
-                   | ((vector int)b & (vector int)c);
-  return (vector float)res;
+  vector int __res = ((vector int)__a & ~(vector int)__c)
+                   | ((vector int)__b & (vector int)__c);
+  return (vector float)__res;
 }
 
 /* vec_vsel */
 
 static vector signed char __ATTRS_o_ai
-vec_vsel(vector signed char a, vector signed char b, vector unsigned char c)
+vec_vsel(vector signed char __a, vector signed char __b, vector unsigned char __c)
 {
-  return (a & ~(vector signed char)c) | (b & (vector signed char)c);
+  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vsel(vector signed char a, vector signed char b, vector bool char c)
+vec_vsel(vector signed char __a, vector signed char __b, vector bool char __c)
 {
-  return (a & ~(vector signed char)c) | (b & (vector signed char)c);
+  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsel(vector unsigned char a, vector unsigned char b, vector unsigned char c)
+vec_vsel(vector unsigned char __a, vector unsigned char __b, vector unsigned char __c)
 {
-  return (a & ~c) | (b & c);
+  return (__a & ~__c) | (__b & __c);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsel(vector unsigned char a, vector unsigned char b, vector bool char c)
+vec_vsel(vector unsigned char __a, vector unsigned char __b, vector bool char __c)
 {
-  return (a & ~(vector unsigned char)c) | (b & (vector unsigned char)c);
+  return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vsel(vector bool char a, vector bool char b, vector unsigned char c)
+vec_vsel(vector bool char __a, vector bool char __b, vector unsigned char __c)
 {
-  return (a & ~(vector bool char)c) | (b & (vector bool char)c);
+  return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vsel(vector bool char a, vector bool char b, vector bool char c)
+vec_vsel(vector bool char __a, vector bool char __b, vector bool char __c)
 {
-  return (a & ~c) | (b & c);
+  return (__a & ~__c) | (__b & __c);
 }
 
 static vector short __ATTRS_o_ai
-vec_vsel(vector short a, vector short b, vector unsigned short c)
+vec_vsel(vector short __a, vector short __b, vector unsigned short __c)
 {
-  return (a & ~(vector short)c) | (b & (vector short)c);
+  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
 }
 
 static vector short __ATTRS_o_ai
-vec_vsel(vector short a, vector short b, vector bool short c)
+vec_vsel(vector short __a, vector short __b, vector bool short __c)
 {
-  return (a & ~(vector short)c) | (b & (vector short)c);
+  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsel(vector unsigned short a,
-         vector unsigned short b,
-         vector unsigned short c)
+vec_vsel(vector unsigned short __a,
+         vector unsigned short __b,
+         vector unsigned short __c)
 {
-  return (a & ~c) | (b & c);
+  return (__a & ~__c) | (__b & __c);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsel(vector unsigned short a, vector unsigned short b, vector bool short c)
+vec_vsel(vector unsigned short __a, vector unsigned short __b, vector bool short __c)
 {
-  return (a & ~(vector unsigned short)c) | (b & (vector unsigned short)c);
+  return (__a & ~(vector unsigned short)__c) | (__b & (vector unsigned short)__c);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vsel(vector bool short a, vector bool short b, vector unsigned short c)
+vec_vsel(vector bool short __a, vector bool short __b, vector unsigned short __c)
 {
-  return (a & ~(vector bool short)c) | (b & (vector bool short)c);
+  return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vsel(vector bool short a, vector bool short b, vector bool short c)
+vec_vsel(vector bool short __a, vector bool short __b, vector bool short __c)
 {
-  return (a & ~c) | (b & c);
+  return (__a & ~__c) | (__b & __c);
 }
 
 static vector int __ATTRS_o_ai
-vec_vsel(vector int a, vector int b, vector unsigned int c)
+vec_vsel(vector int __a, vector int __b, vector unsigned int __c)
 {
-  return (a & ~(vector int)c) | (b & (vector int)c);
+  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
 }
 
 static vector int __ATTRS_o_ai
-vec_vsel(vector int a, vector int b, vector bool int c)
+vec_vsel(vector int __a, vector int __b, vector bool int __c)
 {
-  return (a & ~(vector int)c) | (b & (vector int)c);
+  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsel(vector unsigned int a, vector unsigned int b, vector unsigned int c)
+vec_vsel(vector unsigned int __a, vector unsigned int __b, vector unsigned int __c)
 {
-  return (a & ~c) | (b & c);
+  return (__a & ~__c) | (__b & __c);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsel(vector unsigned int a, vector unsigned int b, vector bool int c)
+vec_vsel(vector unsigned int __a, vector unsigned int __b, vector bool int __c)
 {
-  return (a & ~(vector unsigned int)c) | (b & (vector unsigned int)c);
+  return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vsel(vector bool int a, vector bool int b, vector unsigned int c)
+vec_vsel(vector bool int __a, vector bool int __b, vector unsigned int __c)
 {
-  return (a & ~(vector bool int)c) | (b & (vector bool int)c);
+  return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vsel(vector bool int a, vector bool int b, vector bool int c)
+vec_vsel(vector bool int __a, vector bool int __b, vector bool int __c)
 {
-  return (a & ~c) | (b & c);
+  return (__a & ~__c) | (__b & __c);
 }
 
 static vector float __ATTRS_o_ai
-vec_vsel(vector float a, vector float b, vector unsigned int c)
+vec_vsel(vector float __a, vector float __b, vector unsigned int __c)
 {
-  vector int res = ((vector int)a & ~(vector int)c)
-                   | ((vector int)b & (vector int)c);
-  return (vector float)res;
+  vector int __res = ((vector int)__a & ~(vector int)__c)
+                   | ((vector int)__b & (vector int)__c);
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_vsel(vector float a, vector float b, vector bool int c)
+vec_vsel(vector float __a, vector float __b, vector bool int __c)
 {
-  vector int res = ((vector int)a & ~(vector int)c)
-                   | ((vector int)b & (vector int)c);
-  return (vector float)res;
+  vector int __res = ((vector int)__a & ~(vector int)__c)
+                   | ((vector int)__b & (vector int)__c);
+  return (vector float)__res;
 }
 
 /* vec_sl */
 
 static vector signed char __ATTRS_o_ai
-vec_sl(vector signed char a, vector unsigned char b)
+vec_sl(vector signed char __a, vector unsigned char __b)
 {
-  return a << (vector signed char)b;
+  return __a << (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_sl(vector unsigned char a, vector unsigned char b)
+vec_sl(vector unsigned char __a, vector unsigned char __b)
 {
-  return a << b;
+  return __a << __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_sl(vector short a, vector unsigned short b)
+vec_sl(vector short __a, vector unsigned short __b)
 {
-  return a << (vector short)b;
+  return __a << (vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_sl(vector unsigned short a, vector unsigned short b)
+vec_sl(vector unsigned short __a, vector unsigned short __b)
 {
-  return a << b;
+  return __a << __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_sl(vector int a, vector unsigned int b)
+vec_sl(vector int __a, vector unsigned int __b)
 {
-  return a << (vector int)b;
+  return __a << (vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_sl(vector unsigned int a, vector unsigned int b)
+vec_sl(vector unsigned int __a, vector unsigned int __b)
 {
-  return a << b;
+  return __a << __b;
 }
 
 /* vec_vslb */
@@ -4872,15 +4872,15 @@
 #define __builtin_altivec_vslb vec_vslb
 
 static vector signed char __ATTRS_o_ai
-vec_vslb(vector signed char a, vector unsigned char b)
+vec_vslb(vector signed char __a, vector unsigned char __b)
 {
-  return vec_sl(a, b);
+  return vec_sl(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vslb(vector unsigned char a, vector unsigned char b)
+vec_vslb(vector unsigned char __a, vector unsigned char __b)
 {
-  return vec_sl(a, b);
+  return vec_sl(__a, __b);
 }
 
 /* vec_vslh */
@@ -4888,15 +4888,15 @@
 #define __builtin_altivec_vslh vec_vslh
 
 static vector short __ATTRS_o_ai
-vec_vslh(vector short a, vector unsigned short b)
+vec_vslh(vector short __a, vector unsigned short __b)
 {
-  return vec_sl(a, b);
+  return vec_sl(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vslh(vector unsigned short a, vector unsigned short b)
+vec_vslh(vector unsigned short __a, vector unsigned short __b)
 {
-  return vec_sl(a, b);
+  return vec_sl(__a, __b);
 }
 
 /* vec_vslw */
@@ -4904,15 +4904,15 @@
 #define __builtin_altivec_vslw vec_vslw
 
 static vector int __ATTRS_o_ai
-vec_vslw(vector int a, vector unsigned int b)
+vec_vslw(vector int __a, vector unsigned int __b)
 {
-  return vec_sl(a, b);
+  return vec_sl(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vslw(vector unsigned int a, vector unsigned int b)
+vec_vslw(vector unsigned int __a, vector unsigned int __b)
 {
-  return vec_sl(a, b);
+  return vec_sl(__a, __b);
 }
 
 /* vec_sld */
@@ -4920,825 +4920,825 @@
 #define __builtin_altivec_vsldoi_4si vec_sld
 
 static vector signed char __ATTRS_o_ai
-vec_sld(vector signed char a, vector signed char b, unsigned char c)
+vec_sld(vector signed char __a, vector signed char __b, unsigned char __c)
 {
-  return vec_perm(a, b, (vector unsigned char)
-    (c,   c+1, c+2,  c+3,  c+4,  c+5,  c+6,  c+7, 
-     c+8, c+9, c+10, c+11, c+12, c+13, c+14, c+15));
+  return vec_perm(__a, __b, (vector unsigned char)
+    (__c,   __c+1, __c+2,  __c+3,  __c+4,  __c+5,  __c+6,  __c+7,
+     __c+8, __c+9, __c+10, __c+11, __c+12, __c+13, __c+14, __c+15));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_sld(vector unsigned char a, vector unsigned char b, unsigned char c)
+vec_sld(vector unsigned char __a, vector unsigned char __b, unsigned char __c)
 {
-  return vec_perm(a, b, (vector unsigned char)
-    (c,   c+1, c+2,  c+3,  c+4,  c+5,  c+6,  c+7, 
-     c+8, c+9, c+10, c+11, c+12, c+13, c+14, c+15));
+  return vec_perm(__a, __b, (vector unsigned char)
+    (__c,   __c+1, __c+2,  __c+3,  __c+4,  __c+5,  __c+6,  __c+7,
+     __c+8, __c+9, __c+10, __c+11, __c+12, __c+13, __c+14, __c+15));
 }
 
 static vector short __ATTRS_o_ai
-vec_sld(vector short a, vector short b, unsigned char c)
+vec_sld(vector short __a, vector short __b, unsigned char __c)
 {
-  return vec_perm(a, b, (vector unsigned char)
-    (c,   c+1, c+2,  c+3,  c+4,  c+5,  c+6,  c+7, 
-     c+8, c+9, c+10, c+11, c+12, c+13, c+14, c+15));
+  return vec_perm(__a, __b, (vector unsigned char)
+    (__c,   __c+1, __c+2,  __c+3,  __c+4,  __c+5,  __c+6,  __c+7,
+     __c+8, __c+9, __c+10, __c+11, __c+12, __c+13, __c+14, __c+15));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_sld(vector unsigned short a, vector unsigned short b, unsigned char c)
+vec_sld(vector unsigned short __a, vector unsigned short __b, unsigned char __c)
 {
-  return vec_perm(a, b, (vector unsigned char)
-    (c,   c+1, c+2,  c+3,  c+4,  c+5,  c+6,  c+7, 
-     c+8, c+9, c+10, c+11, c+12, c+13, c+14, c+15));
+  return vec_perm(__a, __b, (vector unsigned char)
+    (__c,   __c+1, __c+2,  __c+3,  __c+4,  __c+5,  __c+6,  __c+7,
+     __c+8, __c+9, __c+10, __c+11, __c+12, __c+13, __c+14, __c+15));
 }
 
 static vector pixel __ATTRS_o_ai
-vec_sld(vector pixel a, vector pixel b, unsigned char c)
+vec_sld(vector pixel __a, vector pixel __b, unsigned char __c)
 {
-  return vec_perm(a, b, (vector unsigned char)
-    (c,   c+1, c+2,  c+3,  c+4,  c+5,  c+6,  c+7, 
-     c+8, c+9, c+10, c+11, c+12, c+13, c+14, c+15));
+  return vec_perm(__a, __b, (vector unsigned char)
+    (__c,   __c+1, __c+2,  __c+3,  __c+4,  __c+5,  __c+6,  __c+7,
+     __c+8, __c+9, __c+10, __c+11, __c+12, __c+13, __c+14, __c+15));
 }
 
 static vector int __ATTRS_o_ai
-vec_sld(vector int a, vector int b, unsigned char c)
+vec_sld(vector int __a, vector int __b, unsigned char __c)
 {
-  return vec_perm(a, b, (vector unsigned char)
-    (c,   c+1, c+2,  c+3,  c+4,  c+5,  c+6,  c+7, 
-     c+8, c+9, c+10, c+11, c+12, c+13, c+14, c+15));
+  return vec_perm(__a, __b, (vector unsigned char)
+    (__c,   __c+1, __c+2,  __c+3,  __c+4,  __c+5,  __c+6,  __c+7,
+     __c+8, __c+9, __c+10, __c+11, __c+12, __c+13, __c+14, __c+15));
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_sld(vector unsigned int a, vector unsigned int b, unsigned char c)
+vec_sld(vector unsigned int __a, vector unsigned int __b, unsigned char __c)
 {
-  return vec_perm(a, b, (vector unsigned char)
-    (c,   c+1, c+2,  c+3,  c+4,  c+5,  c+6,  c+7, 
-     c+8, c+9, c+10, c+11, c+12, c+13, c+14, c+15));
+  return vec_perm(__a, __b, (vector unsigned char)
+    (__c,   __c+1, __c+2,  __c+3,  __c+4,  __c+5,  __c+6,  __c+7,
+     __c+8, __c+9, __c+10, __c+11, __c+12, __c+13, __c+14, __c+15));
 }
 
 static vector float __ATTRS_o_ai
-vec_sld(vector float a, vector float b, unsigned char c)
+vec_sld(vector float __a, vector float __b, unsigned char __c)
 {
-  return vec_perm(a, b, (vector unsigned char)
-    (c,   c+1, c+2,  c+3,  c+4,  c+5,  c+6,  c+7, 
-     c+8, c+9, c+10, c+11, c+12, c+13, c+14, c+15));
+  return vec_perm(__a, __b, (vector unsigned char)
+    (__c,   __c+1, __c+2,  __c+3,  __c+4,  __c+5,  __c+6,  __c+7,
+     __c+8, __c+9, __c+10, __c+11, __c+12, __c+13, __c+14, __c+15));
 }
 
 /* vec_vsldoi */
 
 static vector signed char __ATTRS_o_ai
-vec_vsldoi(vector signed char a, vector signed char b, unsigned char c)
+vec_vsldoi(vector signed char __a, vector signed char __b, unsigned char __c)
 {
-  return vec_perm(a, b, (vector unsigned char)
-    (c,   c+1, c+2,  c+3,  c+4,  c+5,  c+6,  c+7, 
-     c+8, c+9, c+10, c+11, c+12, c+13, c+14, c+15));
+  return vec_perm(__a, __b, (vector unsigned char)
+    (__c,   __c+1, __c+2,  __c+3,  __c+4,  __c+5,  __c+6,  __c+7,
+     __c+8, __c+9, __c+10, __c+11, __c+12, __c+13, __c+14, __c+15));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsldoi(vector unsigned char a, vector unsigned char b, unsigned char c)
+vec_vsldoi(vector unsigned char __a, vector unsigned char __b, unsigned char __c)
 {
-  return vec_perm(a, b, (vector unsigned char)
-    (c,   c+1, c+2,  c+3,  c+4,  c+5,  c+6,  c+7, 
-     c+8, c+9, c+10, c+11, c+12, c+13, c+14, c+15));
+  return vec_perm(__a, __b, (vector unsigned char)
+    (__c,   __c+1, __c+2,  __c+3,  __c+4,  __c+5,  __c+6,  __c+7,
+     __c+8, __c+9, __c+10, __c+11, __c+12, __c+13, __c+14, __c+15));
 }
 
 static vector short __ATTRS_o_ai
-vec_vsldoi(vector short a, vector short b, unsigned char c)
+vec_vsldoi(vector short __a, vector short __b, unsigned char __c)
 {
-  return vec_perm(a, b, (vector unsigned char)
-    (c,   c+1, c+2,  c+3,  c+4,  c+5,  c+6,  c+7, 
-     c+8, c+9, c+10, c+11, c+12, c+13, c+14, c+15));
+  return vec_perm(__a, __b, (vector unsigned char)
+    (__c,   __c+1, __c+2,  __c+3,  __c+4,  __c+5,  __c+6,  __c+7,
+     __c+8, __c+9, __c+10, __c+11, __c+12, __c+13, __c+14, __c+15));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsldoi(vector unsigned short a, vector unsigned short b, unsigned char c)
+vec_vsldoi(vector unsigned short __a, vector unsigned short __b, unsigned char __c)
 {
-  return vec_perm(a, b, (vector unsigned char)
-    (c,   c+1, c+2,  c+3,  c+4,  c+5,  c+6,  c+7, 
-     c+8, c+9, c+10, c+11, c+12, c+13, c+14, c+15));
+  return vec_perm(__a, __b, (vector unsigned char)
+    (__c,   __c+1, __c+2,  __c+3,  __c+4,  __c+5,  __c+6,  __c+7,
+     __c+8, __c+9, __c+10, __c+11, __c+12, __c+13, __c+14, __c+15));
 }
 
 static vector pixel __ATTRS_o_ai
-vec_vsldoi(vector pixel a, vector pixel b, unsigned char c)
+vec_vsldoi(vector pixel __a, vector pixel __b, unsigned char __c)
 {
-  return vec_perm(a, b, (vector unsigned char)
-    (c,   c+1, c+2,  c+3,  c+4,  c+5,  c+6,  c+7, 
-     c+8, c+9, c+10, c+11, c+12, c+13, c+14, c+15));
+  return vec_perm(__a, __b, (vector unsigned char)
+    (__c,   __c+1, __c+2,  __c+3,  __c+4,  __c+5,  __c+6,  __c+7,
+     __c+8, __c+9, __c+10, __c+11, __c+12, __c+13, __c+14, __c+15));
 }
 
 static vector int __ATTRS_o_ai
-vec_vsldoi(vector int a, vector int b, unsigned char c)
+vec_vsldoi(vector int __a, vector int __b, unsigned char __c)
 {
-  return vec_perm(a, b, (vector unsigned char)
-    (c,   c+1, c+2,  c+3,  c+4,  c+5,  c+6,  c+7, 
-     c+8, c+9, c+10, c+11, c+12, c+13, c+14, c+15));
+  return vec_perm(__a, __b, (vector unsigned char)
+    (__c,   __c+1, __c+2,  __c+3,  __c+4,  __c+5,  __c+6,  __c+7,
+     __c+8, __c+9, __c+10, __c+11, __c+12, __c+13, __c+14, __c+15));
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsldoi(vector unsigned int a, vector unsigned int b, unsigned char c)
+vec_vsldoi(vector unsigned int __a, vector unsigned int __b, unsigned char __c)
 {
-  return vec_perm(a, b, (vector unsigned char)
-    (c,   c+1, c+2,  c+3,  c+4,  c+5,  c+6,  c+7, 
-     c+8, c+9, c+10, c+11, c+12, c+13, c+14, c+15));
+  return vec_perm(__a, __b, (vector unsigned char)
+    (__c,   __c+1, __c+2,  __c+3,  __c+4,  __c+5,  __c+6,  __c+7,
+     __c+8, __c+9, __c+10, __c+11, __c+12, __c+13, __c+14, __c+15));
 }
 
 static vector float __ATTRS_o_ai
-vec_vsldoi(vector float a, vector float b, unsigned char c)
+vec_vsldoi(vector float __a, vector float __b, unsigned char __c)
 {
-  return vec_perm(a, b, (vector unsigned char)
-    (c,   c+1, c+2,  c+3,  c+4,  c+5,  c+6,  c+7, 
-     c+8, c+9, c+10, c+11, c+12, c+13, c+14, c+15));
+  return vec_perm(__a, __b, (vector unsigned char)
+    (__c,   __c+1, __c+2,  __c+3,  __c+4,  __c+5,  __c+6,  __c+7,
+     __c+8, __c+9, __c+10, __c+11, __c+12, __c+13, __c+14, __c+15));
 }
 
 /* vec_sll */
 
 static vector signed char __ATTRS_o_ai
-vec_sll(vector signed char a, vector unsigned char b)
+vec_sll(vector signed char __a, vector unsigned char __b)
 {
   return (vector signed char)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_sll(vector signed char a, vector unsigned short b)
+vec_sll(vector signed char __a, vector unsigned short __b)
 {
   return (vector signed char)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_sll(vector signed char a, vector unsigned int b)
+vec_sll(vector signed char __a, vector unsigned int __b)
 {
   return (vector signed char)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_sll(vector unsigned char a, vector unsigned char b)
+vec_sll(vector unsigned char __a, vector unsigned char __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_sll(vector unsigned char a, vector unsigned short b)
+vec_sll(vector unsigned char __a, vector unsigned short __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_sll(vector unsigned char a, vector unsigned int b)
+vec_sll(vector unsigned char __a, vector unsigned int __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_sll(vector bool char a, vector unsigned char b)
+vec_sll(vector bool char __a, vector unsigned char __b)
 {
-  return (vector bool char)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool char)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_sll(vector bool char a, vector unsigned short b)
+vec_sll(vector bool char __a, vector unsigned short __b)
 {
-  return (vector bool char)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool char)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_sll(vector bool char a, vector unsigned int b)
+vec_sll(vector bool char __a, vector unsigned int __b)
 {
-  return (vector bool char)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool char)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_sll(vector short a, vector unsigned char b)
+vec_sll(vector short __a, vector unsigned char __b)
 {
-  return (vector short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_sll(vector short a, vector unsigned short b)
+vec_sll(vector short __a, vector unsigned short __b)
 {
-  return (vector short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_sll(vector short a, vector unsigned int b)
+vec_sll(vector short __a, vector unsigned int __b)
 {
-  return (vector short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_sll(vector unsigned short a, vector unsigned char b)
+vec_sll(vector unsigned short __a, vector unsigned char __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_sll(vector unsigned short a, vector unsigned short b)
+vec_sll(vector unsigned short __a, vector unsigned short __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_sll(vector unsigned short a, vector unsigned int b)
+vec_sll(vector unsigned short __a, vector unsigned int __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_sll(vector bool short a, vector unsigned char b)
+vec_sll(vector bool short __a, vector unsigned char __b)
 {
-  return (vector bool short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_sll(vector bool short a, vector unsigned short b)
+vec_sll(vector bool short __a, vector unsigned short __b)
 {
-  return (vector bool short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_sll(vector bool short a, vector unsigned int b)
+vec_sll(vector bool short __a, vector unsigned int __b)
 {
-  return (vector bool short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_sll(vector pixel a, vector unsigned char b)
+vec_sll(vector pixel __a, vector unsigned char __b)
 {
-  return (vector pixel)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_sll(vector pixel a, vector unsigned short b)
+vec_sll(vector pixel __a, vector unsigned short __b)
 {
-  return (vector pixel)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_sll(vector pixel a, vector unsigned int b)
+vec_sll(vector pixel __a, vector unsigned int __b)
 {
-  return (vector pixel)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_sll(vector int a, vector unsigned char b)
+vec_sll(vector int __a, vector unsigned char __b)
 {
-  return (vector int)__builtin_altivec_vsl(a, (vector int)b);
+  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_sll(vector int a, vector unsigned short b)
+vec_sll(vector int __a, vector unsigned short __b)
 {
-  return (vector int)__builtin_altivec_vsl(a, (vector int)b);
+  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_sll(vector int a, vector unsigned int b)
+vec_sll(vector int __a, vector unsigned int __b)
 {
-  return (vector int)__builtin_altivec_vsl(a, (vector int)b);
+  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_sll(vector unsigned int a, vector unsigned char b)
+vec_sll(vector unsigned int __a, vector unsigned char __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_sll(vector unsigned int a, vector unsigned short b)
+vec_sll(vector unsigned int __a, vector unsigned short __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_sll(vector unsigned int a, vector unsigned int b)
+vec_sll(vector unsigned int __a, vector unsigned int __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_sll(vector bool int a, vector unsigned char b)
+vec_sll(vector bool int __a, vector unsigned char __b)
 {
-  return (vector bool int)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool int)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_sll(vector bool int a, vector unsigned short b)
+vec_sll(vector bool int __a, vector unsigned short __b)
 {
-  return (vector bool int)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool int)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_sll(vector bool int a, vector unsigned int b)
+vec_sll(vector bool int __a, vector unsigned int __b)
 {
-  return (vector bool int)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool int)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 /* vec_vsl */
 
 static vector signed char __ATTRS_o_ai
-vec_vsl(vector signed char a, vector unsigned char b)
+vec_vsl(vector signed char __a, vector unsigned char __b)
 {
   return (vector signed char)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vsl(vector signed char a, vector unsigned short b)
+vec_vsl(vector signed char __a, vector unsigned short __b)
 {
   return (vector signed char)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vsl(vector signed char a, vector unsigned int b)
+vec_vsl(vector signed char __a, vector unsigned int __b)
 {
   return (vector signed char)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsl(vector unsigned char a, vector unsigned char b)
+vec_vsl(vector unsigned char __a, vector unsigned char __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsl(vector unsigned char a, vector unsigned short b)
+vec_vsl(vector unsigned char __a, vector unsigned short __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsl(vector unsigned char a, vector unsigned int b)
+vec_vsl(vector unsigned char __a, vector unsigned int __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vsl(vector bool char a, vector unsigned char b)
+vec_vsl(vector bool char __a, vector unsigned char __b)
 {
-  return (vector bool char)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool char)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vsl(vector bool char a, vector unsigned short b)
+vec_vsl(vector bool char __a, vector unsigned short __b)
 {
-  return (vector bool char)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool char)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vsl(vector bool char a, vector unsigned int b)
+vec_vsl(vector bool char __a, vector unsigned int __b)
 {
-  return (vector bool char)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool char)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vsl(vector short a, vector unsigned char b)
+vec_vsl(vector short __a, vector unsigned char __b)
 {
-  return (vector short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vsl(vector short a, vector unsigned short b)
+vec_vsl(vector short __a, vector unsigned short __b)
 {
-  return (vector short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vsl(vector short a, vector unsigned int b)
+vec_vsl(vector short __a, vector unsigned int __b)
 {
-  return (vector short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsl(vector unsigned short a, vector unsigned char b)
+vec_vsl(vector unsigned short __a, vector unsigned char __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsl(vector unsigned short a, vector unsigned short b)
+vec_vsl(vector unsigned short __a, vector unsigned short __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsl(vector unsigned short a, vector unsigned int b)
+vec_vsl(vector unsigned short __a, vector unsigned int __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vsl(vector bool short a, vector unsigned char b)
+vec_vsl(vector bool short __a, vector unsigned char __b)
 {
-  return (vector bool short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vsl(vector bool short a, vector unsigned short b)
+vec_vsl(vector bool short __a, vector unsigned short __b)
 {
-  return (vector bool short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vsl(vector bool short a, vector unsigned int b)
+vec_vsl(vector bool short __a, vector unsigned int __b)
 {
-  return (vector bool short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_vsl(vector pixel a, vector unsigned char b)
+vec_vsl(vector pixel __a, vector unsigned char __b)
 {
-  return (vector pixel)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_vsl(vector pixel a, vector unsigned short b)
+vec_vsl(vector pixel __a, vector unsigned short __b)
 {
-  return (vector pixel)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_vsl(vector pixel a, vector unsigned int b)
+vec_vsl(vector pixel __a, vector unsigned int __b)
 {
-  return (vector pixel)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vsl(vector int a, vector unsigned char b)
+vec_vsl(vector int __a, vector unsigned char __b)
 {
-  return (vector int)__builtin_altivec_vsl(a, (vector int)b);
+  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vsl(vector int a, vector unsigned short b)
+vec_vsl(vector int __a, vector unsigned short __b)
 {
-  return (vector int)__builtin_altivec_vsl(a, (vector int)b);
+  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vsl(vector int a, vector unsigned int b)
+vec_vsl(vector int __a, vector unsigned int __b)
 {
-  return (vector int)__builtin_altivec_vsl(a, (vector int)b);
+  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsl(vector unsigned int a, vector unsigned char b)
+vec_vsl(vector unsigned int __a, vector unsigned char __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsl(vector unsigned int a, vector unsigned short b)
+vec_vsl(vector unsigned int __a, vector unsigned short __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsl(vector unsigned int a, vector unsigned int b)
+vec_vsl(vector unsigned int __a, vector unsigned int __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vsl((vector int)a, (vector int)b);
+           __builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vsl(vector bool int a, vector unsigned char b)
+vec_vsl(vector bool int __a, vector unsigned char __b)
 {
-  return (vector bool int)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool int)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vsl(vector bool int a, vector unsigned short b)
+vec_vsl(vector bool int __a, vector unsigned short __b)
 {
-  return (vector bool int)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool int)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vsl(vector bool int a, vector unsigned int b)
+vec_vsl(vector bool int __a, vector unsigned int __b)
 {
-  return (vector bool int)__builtin_altivec_vsl((vector int)a, (vector int)b);
+  return (vector bool int)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
 }
 
 /* vec_slo */
 
 static vector signed char __ATTRS_o_ai
-vec_slo(vector signed char a, vector signed char b)
+vec_slo(vector signed char __a, vector signed char __b)
 {
   return (vector signed char)
-           __builtin_altivec_vslo((vector int)a, (vector int)b);
+           __builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_slo(vector signed char a, vector unsigned char b)
+vec_slo(vector signed char __a, vector unsigned char __b)
 {
   return (vector signed char)
-           __builtin_altivec_vslo((vector int)a, (vector int)b);
+           __builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_slo(vector unsigned char a, vector signed char b)
+vec_slo(vector unsigned char __a, vector signed char __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vslo((vector int)a, (vector int)b);
+           __builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_slo(vector unsigned char a, vector unsigned char b)
+vec_slo(vector unsigned char __a, vector unsigned char __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vslo((vector int)a, (vector int)b);
+           __builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_slo(vector short a, vector signed char b)
+vec_slo(vector short __a, vector signed char __b)
 {
-  return (vector short)__builtin_altivec_vslo((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_slo(vector short a, vector unsigned char b)
+vec_slo(vector short __a, vector unsigned char __b)
 {
-  return (vector short)__builtin_altivec_vslo((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_slo(vector unsigned short a, vector signed char b)
+vec_slo(vector unsigned short __a, vector signed char __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vslo((vector int)a, (vector int)b);
+           __builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_slo(vector unsigned short a, vector unsigned char b)
+vec_slo(vector unsigned short __a, vector unsigned char __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vslo((vector int)a, (vector int)b);
+           __builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_slo(vector pixel a, vector signed char b)
+vec_slo(vector pixel __a, vector signed char __b)
 {
-  return (vector pixel)__builtin_altivec_vslo((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_slo(vector pixel a, vector unsigned char b)
+vec_slo(vector pixel __a, vector unsigned char __b)
 {
-  return (vector pixel)__builtin_altivec_vslo((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_slo(vector int a, vector signed char b)
+vec_slo(vector int __a, vector signed char __b)
 {
-  return (vector int)__builtin_altivec_vslo(a, (vector int)b);
+  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_slo(vector int a, vector unsigned char b)
+vec_slo(vector int __a, vector unsigned char __b)
 {
-  return (vector int)__builtin_altivec_vslo(a, (vector int)b);
+  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_slo(vector unsigned int a, vector signed char b)
+vec_slo(vector unsigned int __a, vector signed char __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vslo((vector int)a, (vector int)b);
+           __builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_slo(vector unsigned int a, vector unsigned char b)
+vec_slo(vector unsigned int __a, vector unsigned char __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vslo((vector int)a, (vector int)b);
+           __builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector float __ATTRS_o_ai
-vec_slo(vector float a, vector signed char b)
+vec_slo(vector float __a, vector signed char __b)
 {
-  return (vector float)__builtin_altivec_vslo((vector int)a, (vector int)b);
+  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector float __ATTRS_o_ai
-vec_slo(vector float a, vector unsigned char b)
+vec_slo(vector float __a, vector unsigned char __b)
 {
-  return (vector float)__builtin_altivec_vslo((vector int)a, (vector int)b);
+  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 /* vec_vslo */
 
 static vector signed char __ATTRS_o_ai
-vec_vslo(vector signed char a, vector signed char b)
+vec_vslo(vector signed char __a, vector signed char __b)
 {
   return (vector signed char)
-           __builtin_altivec_vslo((vector int)a, (vector int)b);
+           __builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vslo(vector signed char a, vector unsigned char b)
+vec_vslo(vector signed char __a, vector unsigned char __b)
 {
   return (vector signed char)
-           __builtin_altivec_vslo((vector int)a, (vector int)b);
+           __builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vslo(vector unsigned char a, vector signed char b)
+vec_vslo(vector unsigned char __a, vector signed char __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vslo((vector int)a, (vector int)b);
+           __builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vslo(vector unsigned char a, vector unsigned char b)
+vec_vslo(vector unsigned char __a, vector unsigned char __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vslo((vector int)a, (vector int)b);
+           __builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vslo(vector short a, vector signed char b)
+vec_vslo(vector short __a, vector signed char __b)
 {
-  return (vector short)__builtin_altivec_vslo((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vslo(vector short a, vector unsigned char b)
+vec_vslo(vector short __a, vector unsigned char __b)
 {
-  return (vector short)__builtin_altivec_vslo((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vslo(vector unsigned short a, vector signed char b)
+vec_vslo(vector unsigned short __a, vector signed char __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vslo((vector int)a, (vector int)b);
+           __builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vslo(vector unsigned short a, vector unsigned char b)
+vec_vslo(vector unsigned short __a, vector unsigned char __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vslo((vector int)a, (vector int)b);
+           __builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_vslo(vector pixel a, vector signed char b)
+vec_vslo(vector pixel __a, vector signed char __b)
 {
-  return (vector pixel)__builtin_altivec_vslo((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_vslo(vector pixel a, vector unsigned char b)
+vec_vslo(vector pixel __a, vector unsigned char __b)
 {
-  return (vector pixel)__builtin_altivec_vslo((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vslo(vector int a, vector signed char b)
+vec_vslo(vector int __a, vector signed char __b)
 {
-  return (vector int)__builtin_altivec_vslo(a, (vector int)b);
+  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vslo(vector int a, vector unsigned char b)
+vec_vslo(vector int __a, vector unsigned char __b)
 {
-  return (vector int)__builtin_altivec_vslo(a, (vector int)b);
+  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vslo(vector unsigned int a, vector signed char b)
+vec_vslo(vector unsigned int __a, vector signed char __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vslo((vector int)a, (vector int)b);
+           __builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vslo(vector unsigned int a, vector unsigned char b)
+vec_vslo(vector unsigned int __a, vector unsigned char __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vslo((vector int)a, (vector int)b);
+           __builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector float __ATTRS_o_ai
-vec_vslo(vector float a, vector signed char b)
+vec_vslo(vector float __a, vector signed char __b)
 {
-  return (vector float)__builtin_altivec_vslo((vector int)a, (vector int)b);
+  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 static vector float __ATTRS_o_ai
-vec_vslo(vector float a, vector unsigned char b)
+vec_vslo(vector float __a, vector unsigned char __b)
 {
-  return (vector float)__builtin_altivec_vslo((vector int)a, (vector int)b);
+  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
 }
 
 /* vec_splat */
 
 static vector signed char __ATTRS_o_ai
-vec_splat(vector signed char a, unsigned char b)
+vec_splat(vector signed char __a, unsigned char __b)
 {
-  return vec_perm(a, a, (vector unsigned char)(b));
+  return vec_perm(__a, __a, (vector unsigned char)(__b));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_splat(vector unsigned char a, unsigned char b)
+vec_splat(vector unsigned char __a, unsigned char __b)
 {
-  return vec_perm(a, a, (vector unsigned char)(b));
+  return vec_perm(__a, __a, (vector unsigned char)(__b));
 }
 
 static vector bool char __ATTRS_o_ai
-vec_splat(vector bool char a, unsigned char b)
+vec_splat(vector bool char __a, unsigned char __b)
 {
-  return vec_perm(a, a, (vector unsigned char)(b));
+  return vec_perm(__a, __a, (vector unsigned char)(__b));
 }
 
 static vector short __ATTRS_o_ai
-vec_splat(vector short a, unsigned char b)
+vec_splat(vector short __a, unsigned char __b)
 { 
-  b *= 2;
-  unsigned char b1=b+1;
-  return vec_perm(a, a, (vector unsigned char)
-    (b, b1, b, b1, b, b1, b, b1, b, b1, b, b1, b, b1, b, b1));
+  __b *= 2;
+  unsigned char b1=__b+1;
+  return vec_perm(__a, __a, (vector unsigned char)
+    (__b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_splat(vector unsigned short a, unsigned char b)
+vec_splat(vector unsigned short __a, unsigned char __b)
 { 
-  b *= 2;
-  unsigned char b1=b+1;
-  return vec_perm(a, a, (vector unsigned char)
-    (b, b1, b, b1, b, b1, b, b1, b, b1, b, b1, b, b1, b, b1));
+  __b *= 2;
+  unsigned char b1=__b+1;
+  return vec_perm(__a, __a, (vector unsigned char)
+    (__b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1));
 }
 
 static vector bool short __ATTRS_o_ai
-vec_splat(vector bool short a, unsigned char b)
+vec_splat(vector bool short __a, unsigned char __b)
 { 
-  b *= 2;
-  unsigned char b1=b+1;
-  return vec_perm(a, a, (vector unsigned char)
-    (b, b1, b, b1, b, b1, b, b1, b, b1, b, b1, b, b1, b, b1));
+  __b *= 2;
+  unsigned char b1=__b+1;
+  return vec_perm(__a, __a, (vector unsigned char)
+    (__b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1));
 }
 
 static vector pixel __ATTRS_o_ai
-vec_splat(vector pixel a, unsigned char b)
+vec_splat(vector pixel __a, unsigned char __b)
 { 
-  b *= 2;
-  unsigned char b1=b+1;
-  return vec_perm(a, a, (vector unsigned char)
-    (b, b1, b, b1, b, b1, b, b1, b, b1, b, b1, b, b1, b, b1));
+  __b *= 2;
+  unsigned char b1=__b+1;
+  return vec_perm(__a, __a, (vector unsigned char)
+    (__b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1));
 }
 
 static vector int __ATTRS_o_ai
-vec_splat(vector int a, unsigned char b)
+vec_splat(vector int __a, unsigned char __b)
 { 
-  b *= 4;
-  unsigned char b1=b+1, b2=b+2, b3=b+3;
-  return vec_perm(a, a, (vector unsigned char)
-    (b, b1, b2, b3, b, b1, b2, b3, b, b1, b2, b3, b, b1, b2, b3));
+  __b *= 4;
+  unsigned char b1=__b+1, b2=__b+2, b3=__b+3;
+  return vec_perm(__a, __a, (vector unsigned char)
+    (__b, b1, b2, b3, __b, b1, b2, b3, __b, b1, b2, b3, __b, b1, b2, b3));
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_splat(vector unsigned int a, unsigned char b)
+vec_splat(vector unsigned int __a, unsigned char __b)
 { 
-  b *= 4;
-  unsigned char b1=b+1, b2=b+2, b3=b+3;
-  return vec_perm(a, a, (vector unsigned char)
-    (b, b1, b2, b3, b, b1, b2, b3, b, b1, b2, b3, b, b1, b2, b3));
+  __b *= 4;
+  unsigned char b1=__b+1, b2=__b+2, b3=__b+3;
+  return vec_perm(__a, __a, (vector unsigned char)
+    (__b, b1, b2, b3, __b, b1, b2, b3, __b, b1, b2, b3, __b, b1, b2, b3));
 }
 
 static vector bool int __ATTRS_o_ai
-vec_splat(vector bool int a, unsigned char b)
+vec_splat(vector bool int __a, unsigned char __b)
 { 
-  b *= 4;
-  unsigned char b1=b+1, b2=b+2, b3=b+3;
-  return vec_perm(a, a, (vector unsigned char)
-    (b, b1, b2, b3, b, b1, b2, b3, b, b1, b2, b3, b, b1, b2, b3));
+  __b *= 4;
+  unsigned char b1=__b+1, b2=__b+2, b3=__b+3;
+  return vec_perm(__a, __a, (vector unsigned char)
+    (__b, b1, b2, b3, __b, b1, b2, b3, __b, b1, b2, b3, __b, b1, b2, b3));
 }
 
 static vector float __ATTRS_o_ai
-vec_splat(vector float a, unsigned char b)
+vec_splat(vector float __a, unsigned char __b)
 { 
-  b *= 4;
-  unsigned char b1=b+1, b2=b+2, b3=b+3;
-  return vec_perm(a, a, (vector unsigned char)
-    (b, b1, b2, b3, b, b1, b2, b3, b, b1, b2, b3, b, b1, b2, b3));
+  __b *= 4;
+  unsigned char b1=__b+1, b2=__b+2, b3=__b+3;
+  return vec_perm(__a, __a, (vector unsigned char)
+    (__b, b1, b2, b3, __b, b1, b2, b3, __b, b1, b2, b3, __b, b1, b2, b3));
 }
 
 /* vec_vspltb */
@@ -5746,21 +5746,21 @@
 #define __builtin_altivec_vspltb vec_vspltb
 
 static vector signed char __ATTRS_o_ai
-vec_vspltb(vector signed char a, unsigned char b)
+vec_vspltb(vector signed char __a, unsigned char __b)
 {
-  return vec_perm(a, a, (vector unsigned char)(b));
+  return vec_perm(__a, __a, (vector unsigned char)(__b));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vspltb(vector unsigned char a, unsigned char b)
+vec_vspltb(vector unsigned char __a, unsigned char __b)
 {
-  return vec_perm(a, a, (vector unsigned char)(b));
+  return vec_perm(__a, __a, (vector unsigned char)(__b));
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vspltb(vector bool char a, unsigned char b)
+vec_vspltb(vector bool char __a, unsigned char __b)
 {
-  return vec_perm(a, a, (vector unsigned char)(b));
+  return vec_perm(__a, __a, (vector unsigned char)(__b));
 }
 
 /* vec_vsplth */
@@ -5768,39 +5768,39 @@
 #define __builtin_altivec_vsplth vec_vsplth
 
 static vector short __ATTRS_o_ai
-vec_vsplth(vector short a, unsigned char b)
+vec_vsplth(vector short __a, unsigned char __b)
 {
-  b *= 2;
-  unsigned char b1=b+1;
-  return vec_perm(a, a, (vector unsigned char)
-    (b, b1, b, b1, b, b1, b, b1, b, b1, b, b1, b, b1, b, b1));
+  __b *= 2;
+  unsigned char b1=__b+1;
+  return vec_perm(__a, __a, (vector unsigned char)
+    (__b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsplth(vector unsigned short a, unsigned char b)
+vec_vsplth(vector unsigned short __a, unsigned char __b)
 {
-  b *= 2;
-  unsigned char b1=b+1;
-  return vec_perm(a, a, (vector unsigned char)
-    (b, b1, b, b1, b, b1, b, b1, b, b1, b, b1, b, b1, b, b1));
+  __b *= 2;
+  unsigned char b1=__b+1;
+  return vec_perm(__a, __a, (vector unsigned char)
+    (__b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1));
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vsplth(vector bool short a, unsigned char b)
+vec_vsplth(vector bool short __a, unsigned char __b)
 {
-  b *= 2;
-  unsigned char b1=b+1;
-  return vec_perm(a, a, (vector unsigned char)
-    (b, b1, b, b1, b, b1, b, b1, b, b1, b, b1, b, b1, b, b1));
+  __b *= 2;
+  unsigned char b1=__b+1;
+  return vec_perm(__a, __a, (vector unsigned char)
+    (__b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1));
 }
 
 static vector pixel __ATTRS_o_ai
-vec_vsplth(vector pixel a, unsigned char b)
+vec_vsplth(vector pixel __a, unsigned char __b)
 {
-  b *= 2;
-  unsigned char b1=b+1;
-  return vec_perm(a, a, (vector unsigned char)
-    (b, b1, b, b1, b, b1, b, b1, b, b1, b, b1, b, b1, b, b1));
+  __b *= 2;
+  unsigned char b1=__b+1;
+  return vec_perm(__a, __a, (vector unsigned char)
+    (__b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1, __b, b1));
 }
 
 /* vec_vspltw */
@@ -5808,39 +5808,39 @@
 #define __builtin_altivec_vspltw vec_vspltw
 
 static vector int __ATTRS_o_ai
-vec_vspltw(vector int a, unsigned char b)
+vec_vspltw(vector int __a, unsigned char __b)
 {
-  b *= 4;
-  unsigned char b1=b+1, b2=b+2, b3=b+3;
-  return vec_perm(a, a, (vector unsigned char)
-    (b, b1, b2, b3, b, b1, b2, b3, b, b1, b2, b3, b, b1, b2, b3));
+  __b *= 4;
+  unsigned char b1=__b+1, b2=__b+2, b3=__b+3;
+  return vec_perm(__a, __a, (vector unsigned char)
+    (__b, b1, b2, b3, __b, b1, b2, b3, __b, b1, b2, b3, __b, b1, b2, b3));
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vspltw(vector unsigned int a, unsigned char b)
+vec_vspltw(vector unsigned int __a, unsigned char __b)
 {
-  b *= 4;
-  unsigned char b1=b+1, b2=b+2, b3=b+3;
-  return vec_perm(a, a, (vector unsigned char)
-    (b, b1, b2, b3, b, b1, b2, b3, b, b1, b2, b3, b, b1, b2, b3));
+  __b *= 4;
+  unsigned char b1=__b+1, b2=__b+2, b3=__b+3;
+  return vec_perm(__a, __a, (vector unsigned char)
+    (__b, b1, b2, b3, __b, b1, b2, b3, __b, b1, b2, b3, __b, b1, b2, b3));
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vspltw(vector bool int a, unsigned char b)
+vec_vspltw(vector bool int __a, unsigned char __b)
 {
-  b *= 4;
-  unsigned char b1=b+1, b2=b+2, b3=b+3;
-  return vec_perm(a, a, (vector unsigned char)
-    (b, b1, b2, b3, b, b1, b2, b3, b, b1, b2, b3, b, b1, b2, b3));
+  __b *= 4;
+  unsigned char b1=__b+1, b2=__b+2, b3=__b+3;
+  return vec_perm(__a, __a, (vector unsigned char)
+    (__b, b1, b2, b3, __b, b1, b2, b3, __b, b1, b2, b3, __b, b1, b2, b3));
 }
 
 static vector float __ATTRS_o_ai
-vec_vspltw(vector float a, unsigned char b)
+vec_vspltw(vector float __a, unsigned char __b)
 {
-  b *= 4;
-  unsigned char b1=b+1, b2=b+2, b3=b+3;
-  return vec_perm(a, a, (vector unsigned char)
-    (b, b1, b2, b3, b, b1, b2, b3, b, b1, b2, b3, b, b1, b2, b3));
+  __b *= 4;
+  unsigned char b1=__b+1, b2=__b+2, b3=__b+3;
+  return vec_perm(__a, __a, (vector unsigned char)
+    (__b, b1, b2, b3, __b, b1, b2, b3, __b, b1, b2, b3, __b, b1, b2, b3));
 }
 
 /* vec_splat_s8 */
@@ -5849,18 +5849,18 @@
 
 // FIXME: parameter should be treated as 5-bit signed literal
 static vector signed char __ATTRS_o_ai
-vec_splat_s8(signed char a)
+vec_splat_s8(signed char __a)
 {
-  return (vector signed char)(a);
+  return (vector signed char)(__a);
 }
 
 /* vec_vspltisb */
 
 // FIXME: parameter should be treated as 5-bit signed literal
 static vector signed char __ATTRS_o_ai
-vec_vspltisb(signed char a)
+vec_vspltisb(signed char __a)
 {
-  return (vector signed char)(a);
+  return (vector signed char)(__a);
 }
 
 /* vec_splat_s16 */
@@ -5869,18 +5869,18 @@
 
 // FIXME: parameter should be treated as 5-bit signed literal
 static vector short __ATTRS_o_ai
-vec_splat_s16(signed char a)
+vec_splat_s16(signed char __a)
 {
-  return (vector short)(a);
+  return (vector short)(__a);
 }
 
 /* vec_vspltish */
 
 // FIXME: parameter should be treated as 5-bit signed literal
 static vector short __ATTRS_o_ai
-vec_vspltish(signed char a)
+vec_vspltish(signed char __a)
 {
-  return (vector short)(a);
+  return (vector short)(__a);
 }
 
 /* vec_splat_s32 */
@@ -5889,83 +5889,83 @@
 
 // FIXME: parameter should be treated as 5-bit signed literal
 static vector int __ATTRS_o_ai
-vec_splat_s32(signed char a)
+vec_splat_s32(signed char __a)
 {
-  return (vector int)(a);
+  return (vector int)(__a);
 }
 
 /* vec_vspltisw */
 
 // FIXME: parameter should be treated as 5-bit signed literal
 static vector int __ATTRS_o_ai
-vec_vspltisw(signed char a)
+vec_vspltisw(signed char __a)
 {
-  return (vector int)(a);
+  return (vector int)(__a);
 }
 
 /* vec_splat_u8 */
 
 // FIXME: parameter should be treated as 5-bit signed literal
 static vector unsigned char __ATTRS_o_ai
-vec_splat_u8(unsigned char a)
+vec_splat_u8(unsigned char __a)
 {
-  return (vector unsigned char)(a);
+  return (vector unsigned char)(__a);
 }
 
 /* vec_splat_u16 */
 
 // FIXME: parameter should be treated as 5-bit signed literal
 static vector unsigned short __ATTRS_o_ai
-vec_splat_u16(signed char a)
+vec_splat_u16(signed char __a)
 {
-  return (vector unsigned short)(a);
+  return (vector unsigned short)(__a);
 }
 
 /* vec_splat_u32 */
 
 // FIXME: parameter should be treated as 5-bit signed literal
 static vector unsigned int __ATTRS_o_ai
-vec_splat_u32(signed char a)
+vec_splat_u32(signed char __a)
 {
-  return (vector unsigned int)(a);
+  return (vector unsigned int)(__a);
 }
 
 /* vec_sr */
 
 static vector signed char __ATTRS_o_ai
-vec_sr(vector signed char a, vector unsigned char b)
+vec_sr(vector signed char __a, vector unsigned char __b)
 {
-  return a >> (vector signed char)b;
+  return __a >> (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_sr(vector unsigned char a, vector unsigned char b)
+vec_sr(vector unsigned char __a, vector unsigned char __b)
 {
-  return a >> b;
+  return __a >> __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_sr(vector short a, vector unsigned short b)
+vec_sr(vector short __a, vector unsigned short __b)
 {
-  return a >> (vector short)b;
+  return __a >> (vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_sr(vector unsigned short a, vector unsigned short b)
+vec_sr(vector unsigned short __a, vector unsigned short __b)
 {
-  return a >> b;
+  return __a >> __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_sr(vector int a, vector unsigned int b)
+vec_sr(vector int __a, vector unsigned int __b)
 {
-  return a >> (vector int)b;
+  return __a >> (vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_sr(vector unsigned int a, vector unsigned int b)
+vec_sr(vector unsigned int __a, vector unsigned int __b)
 {
-  return a >> b;
+  return __a >> __b;
 }
 
 /* vec_vsrb */
@@ -5973,15 +5973,15 @@
 #define __builtin_altivec_vsrb vec_vsrb
 
 static vector signed char __ATTRS_o_ai
-vec_vsrb(vector signed char a, vector unsigned char b)
+vec_vsrb(vector signed char __a, vector unsigned char __b)
 {
-  return a >> (vector signed char)b;
+  return __a >> (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsrb(vector unsigned char a, vector unsigned char b)
+vec_vsrb(vector unsigned char __a, vector unsigned char __b)
 {
-  return a >> b;
+  return __a >> __b;
 }
 
 /* vec_vsrh */
@@ -5989,15 +5989,15 @@
 #define __builtin_altivec_vsrh vec_vsrh
 
 static vector short __ATTRS_o_ai
-vec_vsrh(vector short a, vector unsigned short b)
+vec_vsrh(vector short __a, vector unsigned short __b)
 {
-  return a >> (vector short)b;
+  return __a >> (vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsrh(vector unsigned short a, vector unsigned short b)
+vec_vsrh(vector unsigned short __a, vector unsigned short __b)
 {
-  return a >> b;
+  return __a >> __b;
 }
 
 /* vec_vsrw */
@@ -6005,1631 +6005,1631 @@
 #define __builtin_altivec_vsrw vec_vsrw
 
 static vector int __ATTRS_o_ai
-vec_vsrw(vector int a, vector unsigned int b)
+vec_vsrw(vector int __a, vector unsigned int __b)
 {
-  return a >> (vector int)b;
+  return __a >> (vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsrw(vector unsigned int a, vector unsigned int b)
+vec_vsrw(vector unsigned int __a, vector unsigned int __b)
 {
-  return a >> b;
+  return __a >> __b;
 }
 
 /* vec_sra */
 
 static vector signed char __ATTRS_o_ai
-vec_sra(vector signed char a, vector unsigned char b)
+vec_sra(vector signed char __a, vector unsigned char __b)
 {
-  return (vector signed char)__builtin_altivec_vsrab((vector char)a, b);
+  return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_sra(vector unsigned char a, vector unsigned char b)
+vec_sra(vector unsigned char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)__builtin_altivec_vsrab((vector char)a, b);
+  return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_sra(vector short a, vector unsigned short b)
+vec_sra(vector short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vsrah(a, (vector unsigned short)b);
+  return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_sra(vector unsigned short a, vector unsigned short b)
+vec_sra(vector unsigned short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)__builtin_altivec_vsrah((vector short)a, b);
+  return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_sra(vector int a, vector unsigned int b)
+vec_sra(vector int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vsraw(a, b);
+  return __builtin_altivec_vsraw(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_sra(vector unsigned int a, vector unsigned int b)
+vec_sra(vector unsigned int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)__builtin_altivec_vsraw((vector int)a, b);
+  return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
 }
 
 /* vec_vsrab */
 
 static vector signed char __ATTRS_o_ai
-vec_vsrab(vector signed char a, vector unsigned char b)
+vec_vsrab(vector signed char __a, vector unsigned char __b)
 {
-  return (vector signed char)__builtin_altivec_vsrab((vector char)a, b);
+  return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsrab(vector unsigned char a, vector unsigned char b)
+vec_vsrab(vector unsigned char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)__builtin_altivec_vsrab((vector char)a, b);
+  return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
 }
 
 /* vec_vsrah */
 
 static vector short __ATTRS_o_ai
-vec_vsrah(vector short a, vector unsigned short b)
+vec_vsrah(vector short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vsrah(a, (vector unsigned short)b);
+  return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsrah(vector unsigned short a, vector unsigned short b)
+vec_vsrah(vector unsigned short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)__builtin_altivec_vsrah((vector short)a, b);
+  return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
 }
 
 /* vec_vsraw */
 
 static vector int __ATTRS_o_ai
-vec_vsraw(vector int a, vector unsigned int b)
+vec_vsraw(vector int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vsraw(a, b);
+  return __builtin_altivec_vsraw(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsraw(vector unsigned int a, vector unsigned int b)
+vec_vsraw(vector unsigned int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)__builtin_altivec_vsraw((vector int)a, b);
+  return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
 }
 
 /* vec_srl */
 
 static vector signed char __ATTRS_o_ai
-vec_srl(vector signed char a, vector unsigned char b)
+vec_srl(vector signed char __a, vector unsigned char __b)
 {
   return (vector signed char)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_srl(vector signed char a, vector unsigned short b)
+vec_srl(vector signed char __a, vector unsigned short __b)
 {
   return (vector signed char)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_srl(vector signed char a, vector unsigned int b)
+vec_srl(vector signed char __a, vector unsigned int __b)
 {
   return (vector signed char)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_srl(vector unsigned char a, vector unsigned char b)
+vec_srl(vector unsigned char __a, vector unsigned char __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_srl(vector unsigned char a, vector unsigned short b)
+vec_srl(vector unsigned char __a, vector unsigned short __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_srl(vector unsigned char a, vector unsigned int b)
+vec_srl(vector unsigned char __a, vector unsigned int __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_srl(vector bool char a, vector unsigned char b)
+vec_srl(vector bool char __a, vector unsigned char __b)
 {
-  return (vector bool char)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool char)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_srl(vector bool char a, vector unsigned short b)
+vec_srl(vector bool char __a, vector unsigned short __b)
 {
-  return (vector bool char)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool char)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_srl(vector bool char a, vector unsigned int b)
+vec_srl(vector bool char __a, vector unsigned int __b)
 {
-  return (vector bool char)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool char)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_srl(vector short a, vector unsigned char b)
+vec_srl(vector short __a, vector unsigned char __b)
 {
-  return (vector short)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_srl(vector short a, vector unsigned short b)
+vec_srl(vector short __a, vector unsigned short __b)
 {
-  return (vector short)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_srl(vector short a, vector unsigned int b)
+vec_srl(vector short __a, vector unsigned int __b)
 {
-  return (vector short)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_srl(vector unsigned short a, vector unsigned char b)
+vec_srl(vector unsigned short __a, vector unsigned char __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_srl(vector unsigned short a, vector unsigned short b)
+vec_srl(vector unsigned short __a, vector unsigned short __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_srl(vector unsigned short a, vector unsigned int b)
+vec_srl(vector unsigned short __a, vector unsigned int __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_srl(vector bool short a, vector unsigned char b)
+vec_srl(vector bool short __a, vector unsigned char __b)
 {
-  return (vector bool short)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_srl(vector bool short a, vector unsigned short b)
+vec_srl(vector bool short __a, vector unsigned short __b)
 {
-  return (vector bool short)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_srl(vector bool short a, vector unsigned int b)
+vec_srl(vector bool short __a, vector unsigned int __b)
 {
-  return (vector bool short)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_srl(vector pixel a, vector unsigned char b)
+vec_srl(vector pixel __a, vector unsigned char __b)
 {
-  return (vector pixel)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_srl(vector pixel a, vector unsigned short b)
+vec_srl(vector pixel __a, vector unsigned short __b)
 {
-  return (vector pixel)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_srl(vector pixel a, vector unsigned int b)
+vec_srl(vector pixel __a, vector unsigned int __b)
 {
-  return (vector pixel)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_srl(vector int a, vector unsigned char b)
+vec_srl(vector int __a, vector unsigned char __b)
 {
-  return (vector int)__builtin_altivec_vsr(a, (vector int)b);
+  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_srl(vector int a, vector unsigned short b)
+vec_srl(vector int __a, vector unsigned short __b)
 {
-  return (vector int)__builtin_altivec_vsr(a, (vector int)b);
+  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_srl(vector int a, vector unsigned int b)
+vec_srl(vector int __a, vector unsigned int __b)
 {
-  return (vector int)__builtin_altivec_vsr(a, (vector int)b);
+  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_srl(vector unsigned int a, vector unsigned char b)
+vec_srl(vector unsigned int __a, vector unsigned char __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_srl(vector unsigned int a, vector unsigned short b)
+vec_srl(vector unsigned int __a, vector unsigned short __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_srl(vector unsigned int a, vector unsigned int b)
+vec_srl(vector unsigned int __a, vector unsigned int __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_srl(vector bool int a, vector unsigned char b)
+vec_srl(vector bool int __a, vector unsigned char __b)
 {
-  return (vector bool int)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool int)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_srl(vector bool int a, vector unsigned short b)
+vec_srl(vector bool int __a, vector unsigned short __b)
 {
-  return (vector bool int)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool int)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_srl(vector bool int a, vector unsigned int b)
+vec_srl(vector bool int __a, vector unsigned int __b)
 {
-  return (vector bool int)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool int)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 /* vec_vsr */
 
 static vector signed char __ATTRS_o_ai
-vec_vsr(vector signed char a, vector unsigned char b)
+vec_vsr(vector signed char __a, vector unsigned char __b)
 {
   return (vector signed char)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vsr(vector signed char a, vector unsigned short b)
+vec_vsr(vector signed char __a, vector unsigned short __b)
 {
   return (vector signed char)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vsr(vector signed char a, vector unsigned int b)
+vec_vsr(vector signed char __a, vector unsigned int __b)
 {
   return (vector signed char)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsr(vector unsigned char a, vector unsigned char b)
+vec_vsr(vector unsigned char __a, vector unsigned char __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsr(vector unsigned char a, vector unsigned short b)
+vec_vsr(vector unsigned char __a, vector unsigned short __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsr(vector unsigned char a, vector unsigned int b)
+vec_vsr(vector unsigned char __a, vector unsigned int __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vsr(vector bool char a, vector unsigned char b)
+vec_vsr(vector bool char __a, vector unsigned char __b)
 {
-  return (vector bool char)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool char)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vsr(vector bool char a, vector unsigned short b)
+vec_vsr(vector bool char __a, vector unsigned short __b)
 {
-  return (vector bool char)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool char)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vsr(vector bool char a, vector unsigned int b)
+vec_vsr(vector bool char __a, vector unsigned int __b)
 {
-  return (vector bool char)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool char)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vsr(vector short a, vector unsigned char b)
+vec_vsr(vector short __a, vector unsigned char __b)
 {
-  return (vector short)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vsr(vector short a, vector unsigned short b)
+vec_vsr(vector short __a, vector unsigned short __b)
 {
-  return (vector short)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vsr(vector short a, vector unsigned int b)
+vec_vsr(vector short __a, vector unsigned int __b)
 {
-  return (vector short)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsr(vector unsigned short a, vector unsigned char b)
+vec_vsr(vector unsigned short __a, vector unsigned char __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsr(vector unsigned short a, vector unsigned short b)
+vec_vsr(vector unsigned short __a, vector unsigned short __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsr(vector unsigned short a, vector unsigned int b)
+vec_vsr(vector unsigned short __a, vector unsigned int __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vsr(vector bool short a, vector unsigned char b)
+vec_vsr(vector bool short __a, vector unsigned char __b)
 {
-  return (vector bool short)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vsr(vector bool short a, vector unsigned short b)
+vec_vsr(vector bool short __a, vector unsigned short __b)
 {
-  return (vector bool short)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vsr(vector bool short a, vector unsigned int b)
+vec_vsr(vector bool short __a, vector unsigned int __b)
 {
-  return (vector bool short)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_vsr(vector pixel a, vector unsigned char b)
+vec_vsr(vector pixel __a, vector unsigned char __b)
 {
-  return (vector pixel)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_vsr(vector pixel a, vector unsigned short b)
+vec_vsr(vector pixel __a, vector unsigned short __b)
 {
-  return (vector pixel)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_vsr(vector pixel a, vector unsigned int b)
+vec_vsr(vector pixel __a, vector unsigned int __b)
 {
-  return (vector pixel)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vsr(vector int a, vector unsigned char b)
+vec_vsr(vector int __a, vector unsigned char __b)
 {
-  return (vector int)__builtin_altivec_vsr(a, (vector int)b);
+  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vsr(vector int a, vector unsigned short b)
+vec_vsr(vector int __a, vector unsigned short __b)
 {
-  return (vector int)__builtin_altivec_vsr(a, (vector int)b);
+  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vsr(vector int a, vector unsigned int b)
+vec_vsr(vector int __a, vector unsigned int __b)
 {
-  return (vector int)__builtin_altivec_vsr(a, (vector int)b);
+  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsr(vector unsigned int a, vector unsigned char b)
+vec_vsr(vector unsigned int __a, vector unsigned char __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsr(vector unsigned int a, vector unsigned short b)
+vec_vsr(vector unsigned int __a, vector unsigned short __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsr(vector unsigned int a, vector unsigned int b)
+vec_vsr(vector unsigned int __a, vector unsigned int __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vsr((vector int)a, (vector int)b);
+           __builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vsr(vector bool int a, vector unsigned char b)
+vec_vsr(vector bool int __a, vector unsigned char __b)
 {
-  return (vector bool int)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool int)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vsr(vector bool int a, vector unsigned short b)
+vec_vsr(vector bool int __a, vector unsigned short __b)
 {
-  return (vector bool int)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool int)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vsr(vector bool int a, vector unsigned int b)
+vec_vsr(vector bool int __a, vector unsigned int __b)
 {
-  return (vector bool int)__builtin_altivec_vsr((vector int)a, (vector int)b);
+  return (vector bool int)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
 }
 
 /* vec_sro */
 
 static vector signed char __ATTRS_o_ai
-vec_sro(vector signed char a, vector signed char b)
+vec_sro(vector signed char __a, vector signed char __b)
 {
   return (vector signed char)
-           __builtin_altivec_vsro((vector int)a, (vector int)b);
+           __builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_sro(vector signed char a, vector unsigned char b)
+vec_sro(vector signed char __a, vector unsigned char __b)
 {
   return (vector signed char)
-           __builtin_altivec_vsro((vector int)a, (vector int)b);
+           __builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_sro(vector unsigned char a, vector signed char b)
+vec_sro(vector unsigned char __a, vector signed char __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vsro((vector int)a, (vector int)b);
+           __builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_sro(vector unsigned char a, vector unsigned char b)
+vec_sro(vector unsigned char __a, vector unsigned char __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vsro((vector int)a, (vector int)b);
+           __builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_sro(vector short a, vector signed char b)
+vec_sro(vector short __a, vector signed char __b)
 {
-  return (vector short)__builtin_altivec_vsro((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_sro(vector short a, vector unsigned char b)
+vec_sro(vector short __a, vector unsigned char __b)
 {
-  return (vector short)__builtin_altivec_vsro((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_sro(vector unsigned short a, vector signed char b)
+vec_sro(vector unsigned short __a, vector signed char __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vsro((vector int)a, (vector int)b);
+           __builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_sro(vector unsigned short a, vector unsigned char b)
+vec_sro(vector unsigned short __a, vector unsigned char __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vsro((vector int)a, (vector int)b);
+           __builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_sro(vector pixel a, vector signed char b)
+vec_sro(vector pixel __a, vector signed char __b)
 {
-  return (vector pixel)__builtin_altivec_vsro((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_sro(vector pixel a, vector unsigned char b)
+vec_sro(vector pixel __a, vector unsigned char __b)
 {
-  return (vector pixel)__builtin_altivec_vsro((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_sro(vector int a, vector signed char b)
+vec_sro(vector int __a, vector signed char __b)
 {
-  return (vector int)__builtin_altivec_vsro(a, (vector int)b);
+  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_sro(vector int a, vector unsigned char b)
+vec_sro(vector int __a, vector unsigned char __b)
 {
-  return (vector int)__builtin_altivec_vsro(a, (vector int)b);
+  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_sro(vector unsigned int a, vector signed char b)
+vec_sro(vector unsigned int __a, vector signed char __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vsro((vector int)a, (vector int)b);
+           __builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_sro(vector unsigned int a, vector unsigned char b)
+vec_sro(vector unsigned int __a, vector unsigned char __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vsro((vector int)a, (vector int)b);
+           __builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector float __ATTRS_o_ai
-vec_sro(vector float a, vector signed char b)
+vec_sro(vector float __a, vector signed char __b)
 {
-  return (vector float)__builtin_altivec_vsro((vector int)a, (vector int)b);
+  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector float __ATTRS_o_ai
-vec_sro(vector float a, vector unsigned char b)
+vec_sro(vector float __a, vector unsigned char __b)
 {
-  return (vector float)__builtin_altivec_vsro((vector int)a, (vector int)b);
+  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 /* vec_vsro */
 
 static vector signed char __ATTRS_o_ai
-vec_vsro(vector signed char a, vector signed char b)
+vec_vsro(vector signed char __a, vector signed char __b)
 {
   return (vector signed char)
-           __builtin_altivec_vsro((vector int)a, (vector int)b);
+           __builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vsro(vector signed char a, vector unsigned char b)
+vec_vsro(vector signed char __a, vector unsigned char __b)
 {
   return (vector signed char)
-           __builtin_altivec_vsro((vector int)a, (vector int)b);
+           __builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsro(vector unsigned char a, vector signed char b)
+vec_vsro(vector unsigned char __a, vector signed char __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vsro((vector int)a, (vector int)b);
+           __builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsro(vector unsigned char a, vector unsigned char b)
+vec_vsro(vector unsigned char __a, vector unsigned char __b)
 {
   return (vector unsigned char)
-           __builtin_altivec_vsro((vector int)a, (vector int)b);
+           __builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vsro(vector short a, vector signed char b)
+vec_vsro(vector short __a, vector signed char __b)
 {
-  return (vector short)__builtin_altivec_vsro((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vsro(vector short a, vector unsigned char b)
+vec_vsro(vector short __a, vector unsigned char __b)
 {
-  return (vector short)__builtin_altivec_vsro((vector int)a, (vector int)b);
+  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsro(vector unsigned short a, vector signed char b)
+vec_vsro(vector unsigned short __a, vector signed char __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vsro((vector int)a, (vector int)b);
+           __builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsro(vector unsigned short a, vector unsigned char b)
+vec_vsro(vector unsigned short __a, vector unsigned char __b)
 {
   return (vector unsigned short)
-           __builtin_altivec_vsro((vector int)a, (vector int)b);
+           __builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_vsro(vector pixel a, vector signed char b)
+vec_vsro(vector pixel __a, vector signed char __b)
 {
-  return (vector pixel)__builtin_altivec_vsro((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector pixel __ATTRS_o_ai
-vec_vsro(vector pixel a, vector unsigned char b)
+vec_vsro(vector pixel __a, vector unsigned char __b)
 {
-  return (vector pixel)__builtin_altivec_vsro((vector int)a, (vector int)b);
+  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vsro(vector int a, vector signed char b)
+vec_vsro(vector int __a, vector signed char __b)
 {
-  return (vector int)__builtin_altivec_vsro(a, (vector int)b);
+  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vsro(vector int a, vector unsigned char b)
+vec_vsro(vector int __a, vector unsigned char __b)
 {
-  return (vector int)__builtin_altivec_vsro(a, (vector int)b);
+  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsro(vector unsigned int a, vector signed char b)
+vec_vsro(vector unsigned int __a, vector signed char __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vsro((vector int)a, (vector int)b);
+           __builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsro(vector unsigned int a, vector unsigned char b)
+vec_vsro(vector unsigned int __a, vector unsigned char __b)
 {
   return (vector unsigned int)
-           __builtin_altivec_vsro((vector int)a, (vector int)b);
+           __builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector float __ATTRS_o_ai
-vec_vsro(vector float a, vector signed char b)
+vec_vsro(vector float __a, vector signed char __b)
 {
-  return (vector float)__builtin_altivec_vsro((vector int)a, (vector int)b);
+  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 static vector float __ATTRS_o_ai
-vec_vsro(vector float a, vector unsigned char b)
+vec_vsro(vector float __a, vector unsigned char __b)
 {
-  return (vector float)__builtin_altivec_vsro((vector int)a, (vector int)b);
+  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
 }
 
 /* vec_st */
 
 static void __ATTRS_o_ai
-vec_st(vector signed char a, int b, vector signed char *c)
+vec_st(vector signed char __a, int __b, vector signed char *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector signed char a, int b, signed char *c)
+vec_st(vector signed char __a, int __b, signed char *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector unsigned char a, int b, vector unsigned char *c)
+vec_st(vector unsigned char __a, int __b, vector unsigned char *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector unsigned char a, int b, unsigned char *c)
+vec_st(vector unsigned char __a, int __b, unsigned char *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector bool char a, int b, signed char *c)
+vec_st(vector bool char __a, int __b, signed char *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector bool char a, int b, unsigned char *c)
+vec_st(vector bool char __a, int __b, unsigned char *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector bool char a, int b, vector bool char *c)
+vec_st(vector bool char __a, int __b, vector bool char *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector short a, int b, vector short *c)
+vec_st(vector short __a, int __b, vector short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector short a, int b, short *c)
+vec_st(vector short __a, int __b, short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector unsigned short a, int b, vector unsigned short *c)
+vec_st(vector unsigned short __a, int __b, vector unsigned short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector unsigned short a, int b, unsigned short *c)
+vec_st(vector unsigned short __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector bool short a, int b, short *c)
+vec_st(vector bool short __a, int __b, short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector bool short a, int b, unsigned short *c)
+vec_st(vector bool short __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector bool short a, int b, vector bool short *c)
+vec_st(vector bool short __a, int __b, vector bool short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector pixel a, int b, short *c)
+vec_st(vector pixel __a, int __b, short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector pixel a, int b, unsigned short *c)
+vec_st(vector pixel __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector pixel a, int b, vector pixel *c)
+vec_st(vector pixel __a, int __b, vector pixel *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector int a, int b, vector int *c)
+vec_st(vector int __a, int __b, vector int *__c)
 {
-  __builtin_altivec_stvx(a, b, c);
+  __builtin_altivec_stvx(__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector int a, int b, int *c)
+vec_st(vector int __a, int __b, int *__c)
 {
-  __builtin_altivec_stvx(a, b, c);
+  __builtin_altivec_stvx(__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector unsigned int a, int b, vector unsigned int *c)
+vec_st(vector unsigned int __a, int __b, vector unsigned int *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector unsigned int a, int b, unsigned int *c)
+vec_st(vector unsigned int __a, int __b, unsigned int *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector bool int a, int b, int *c)
+vec_st(vector bool int __a, int __b, int *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector bool int a, int b, unsigned int *c)
+vec_st(vector bool int __a, int __b, unsigned int *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector bool int a, int b, vector bool int *c)
+vec_st(vector bool int __a, int __b, vector bool int *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector float a, int b, vector float *c)
+vec_st(vector float __a, int __b, vector float *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_st(vector float a, int b, float *c)
+vec_st(vector float __a, int __b, float *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 /* vec_stvx */
 
 static void __ATTRS_o_ai
-vec_stvx(vector signed char a, int b, vector signed char *c)
+vec_stvx(vector signed char __a, int __b, vector signed char *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector signed char a, int b, signed char *c)
+vec_stvx(vector signed char __a, int __b, signed char *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector unsigned char a, int b, vector unsigned char *c)
+vec_stvx(vector unsigned char __a, int __b, vector unsigned char *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector unsigned char a, int b, unsigned char *c)
+vec_stvx(vector unsigned char __a, int __b, unsigned char *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector bool char a, int b, signed char *c)
+vec_stvx(vector bool char __a, int __b, signed char *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector bool char a, int b, unsigned char *c)
+vec_stvx(vector bool char __a, int __b, unsigned char *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector bool char a, int b, vector bool char *c)
+vec_stvx(vector bool char __a, int __b, vector bool char *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector short a, int b, vector short *c)
+vec_stvx(vector short __a, int __b, vector short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector short a, int b, short *c)
+vec_stvx(vector short __a, int __b, short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector unsigned short a, int b, vector unsigned short *c)
+vec_stvx(vector unsigned short __a, int __b, vector unsigned short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector unsigned short a, int b, unsigned short *c)
+vec_stvx(vector unsigned short __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector bool short a, int b, short *c)
+vec_stvx(vector bool short __a, int __b, short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector bool short a, int b, unsigned short *c)
+vec_stvx(vector bool short __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector bool short a, int b, vector bool short *c)
+vec_stvx(vector bool short __a, int __b, vector bool short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector pixel a, int b, short *c)
+vec_stvx(vector pixel __a, int __b, short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector pixel a, int b, unsigned short *c)
+vec_stvx(vector pixel __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector pixel a, int b, vector pixel *c)
+vec_stvx(vector pixel __a, int __b, vector pixel *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector int a, int b, vector int *c)
+vec_stvx(vector int __a, int __b, vector int *__c)
 {
-  __builtin_altivec_stvx(a, b, c);
+  __builtin_altivec_stvx(__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector int a, int b, int *c)
+vec_stvx(vector int __a, int __b, int *__c)
 {
-  __builtin_altivec_stvx(a, b, c);
+  __builtin_altivec_stvx(__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector unsigned int a, int b, vector unsigned int *c)
+vec_stvx(vector unsigned int __a, int __b, vector unsigned int *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector unsigned int a, int b, unsigned int *c)
+vec_stvx(vector unsigned int __a, int __b, unsigned int *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector bool int a, int b, int *c)
+vec_stvx(vector bool int __a, int __b, int *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector bool int a, int b, unsigned int *c)
+vec_stvx(vector bool int __a, int __b, unsigned int *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector bool int a, int b, vector bool int *c)
+vec_stvx(vector bool int __a, int __b, vector bool int *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector float a, int b, vector float *c)
+vec_stvx(vector float __a, int __b, vector float *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvx(vector float a, int b, float *c)
+vec_stvx(vector float __a, int __b, float *__c)
 {
-  __builtin_altivec_stvx((vector int)a, b, c);
+  __builtin_altivec_stvx((vector int)__a, __b, __c);
 }
 
 /* vec_ste */
 
 static void __ATTRS_o_ai
-vec_ste(vector signed char a, int b, signed char *c)
+vec_ste(vector signed char __a, int __b, signed char *__c)
 {
-  __builtin_altivec_stvebx((vector char)a, b, c);
+  __builtin_altivec_stvebx((vector char)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_ste(vector unsigned char a, int b, unsigned char *c)
+vec_ste(vector unsigned char __a, int __b, unsigned char *__c)
 {
-  __builtin_altivec_stvebx((vector char)a, b, c);
+  __builtin_altivec_stvebx((vector char)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_ste(vector bool char a, int b, signed char *c)
+vec_ste(vector bool char __a, int __b, signed char *__c)
 {
-  __builtin_altivec_stvebx((vector char)a, b, c);
+  __builtin_altivec_stvebx((vector char)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_ste(vector bool char a, int b, unsigned char *c)
+vec_ste(vector bool char __a, int __b, unsigned char *__c)
 {
-  __builtin_altivec_stvebx((vector char)a, b, c);
+  __builtin_altivec_stvebx((vector char)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_ste(vector short a, int b, short *c)
+vec_ste(vector short __a, int __b, short *__c)
 {
-  __builtin_altivec_stvehx(a, b, c);
+  __builtin_altivec_stvehx(__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_ste(vector unsigned short a, int b, unsigned short *c)
+vec_ste(vector unsigned short __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvehx((vector short)a, b, c);
+  __builtin_altivec_stvehx((vector short)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_ste(vector bool short a, int b, short *c)
+vec_ste(vector bool short __a, int __b, short *__c)
 {
-  __builtin_altivec_stvehx((vector short)a, b, c);
+  __builtin_altivec_stvehx((vector short)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_ste(vector bool short a, int b, unsigned short *c)
+vec_ste(vector bool short __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvehx((vector short)a, b, c);
+  __builtin_altivec_stvehx((vector short)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_ste(vector pixel a, int b, short *c)
+vec_ste(vector pixel __a, int __b, short *__c)
 {
-  __builtin_altivec_stvehx((vector short)a, b, c);
+  __builtin_altivec_stvehx((vector short)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_ste(vector pixel a, int b, unsigned short *c)
+vec_ste(vector pixel __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvehx((vector short)a, b, c);
+  __builtin_altivec_stvehx((vector short)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_ste(vector int a, int b, int *c)
+vec_ste(vector int __a, int __b, int *__c)
 {
-  __builtin_altivec_stvewx(a, b, c);
+  __builtin_altivec_stvewx(__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_ste(vector unsigned int a, int b, unsigned int *c)
+vec_ste(vector unsigned int __a, int __b, unsigned int *__c)
 {
-  __builtin_altivec_stvewx((vector int)a, b, c);
+  __builtin_altivec_stvewx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_ste(vector bool int a, int b, int *c)
+vec_ste(vector bool int __a, int __b, int *__c)
 {
-  __builtin_altivec_stvewx((vector int)a, b, c);
+  __builtin_altivec_stvewx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_ste(vector bool int a, int b, unsigned int *c)
+vec_ste(vector bool int __a, int __b, unsigned int *__c)
 {
-  __builtin_altivec_stvewx((vector int)a, b, c);
+  __builtin_altivec_stvewx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_ste(vector float a, int b, float *c)
+vec_ste(vector float __a, int __b, float *__c)
 {
-  __builtin_altivec_stvewx((vector int)a, b, c);
+  __builtin_altivec_stvewx((vector int)__a, __b, __c);
 }
 
 /* vec_stvebx */
 
 static void __ATTRS_o_ai
-vec_stvebx(vector signed char a, int b, signed char *c)
+vec_stvebx(vector signed char __a, int __b, signed char *__c)
 {
-  __builtin_altivec_stvebx((vector char)a, b, c);
+  __builtin_altivec_stvebx((vector char)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvebx(vector unsigned char a, int b, unsigned char *c)
+vec_stvebx(vector unsigned char __a, int __b, unsigned char *__c)
 {
-  __builtin_altivec_stvebx((vector char)a, b, c);
+  __builtin_altivec_stvebx((vector char)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvebx(vector bool char a, int b, signed char *c)
+vec_stvebx(vector bool char __a, int __b, signed char *__c)
 {
-  __builtin_altivec_stvebx((vector char)a, b, c);
+  __builtin_altivec_stvebx((vector char)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvebx(vector bool char a, int b, unsigned char *c)
+vec_stvebx(vector bool char __a, int __b, unsigned char *__c)
 {
-  __builtin_altivec_stvebx((vector char)a, b, c);
+  __builtin_altivec_stvebx((vector char)__a, __b, __c);
 }
 
 /* vec_stvehx */
 
 static void __ATTRS_o_ai
-vec_stvehx(vector short a, int b, short *c)
+vec_stvehx(vector short __a, int __b, short *__c)
 {
-  __builtin_altivec_stvehx(a, b, c);
+  __builtin_altivec_stvehx(__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvehx(vector unsigned short a, int b, unsigned short *c)
+vec_stvehx(vector unsigned short __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvehx((vector short)a, b, c);
+  __builtin_altivec_stvehx((vector short)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvehx(vector bool short a, int b, short *c)
+vec_stvehx(vector bool short __a, int __b, short *__c)
 {
-  __builtin_altivec_stvehx((vector short)a, b, c);
+  __builtin_altivec_stvehx((vector short)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvehx(vector bool short a, int b, unsigned short *c)
+vec_stvehx(vector bool short __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvehx((vector short)a, b, c);
+  __builtin_altivec_stvehx((vector short)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvehx(vector pixel a, int b, short *c)
+vec_stvehx(vector pixel __a, int __b, short *__c)
 {
-  __builtin_altivec_stvehx((vector short)a, b, c);
+  __builtin_altivec_stvehx((vector short)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvehx(vector pixel a, int b, unsigned short *c)
+vec_stvehx(vector pixel __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvehx((vector short)a, b, c);
+  __builtin_altivec_stvehx((vector short)__a, __b, __c);
 }
 
 /* vec_stvewx */
 
 static void __ATTRS_o_ai
-vec_stvewx(vector int a, int b, int *c)
+vec_stvewx(vector int __a, int __b, int *__c)
 {
-  __builtin_altivec_stvewx(a, b, c);
+  __builtin_altivec_stvewx(__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvewx(vector unsigned int a, int b, unsigned int *c)
+vec_stvewx(vector unsigned int __a, int __b, unsigned int *__c)
 {
-  __builtin_altivec_stvewx((vector int)a, b, c);
+  __builtin_altivec_stvewx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvewx(vector bool int a, int b, int *c)
+vec_stvewx(vector bool int __a, int __b, int *__c)
 {
-  __builtin_altivec_stvewx((vector int)a, b, c);
+  __builtin_altivec_stvewx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvewx(vector bool int a, int b, unsigned int *c)
+vec_stvewx(vector bool int __a, int __b, unsigned int *__c)
 {
-  __builtin_altivec_stvewx((vector int)a, b, c);
+  __builtin_altivec_stvewx((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvewx(vector float a, int b, float *c)
+vec_stvewx(vector float __a, int __b, float *__c)
 {
-  __builtin_altivec_stvewx((vector int)a, b, c);
+  __builtin_altivec_stvewx((vector int)__a, __b, __c);
 }
 
 /* vec_stl */
 
 static void __ATTRS_o_ai
-vec_stl(vector signed char a, int b, vector signed char *c)
+vec_stl(vector signed char __a, int __b, vector signed char *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector signed char a, int b, signed char *c)
+vec_stl(vector signed char __a, int __b, signed char *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector unsigned char a, int b, vector unsigned char *c)
+vec_stl(vector unsigned char __a, int __b, vector unsigned char *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector unsigned char a, int b, unsigned char *c)
+vec_stl(vector unsigned char __a, int __b, unsigned char *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector bool char a, int b, signed char *c)
+vec_stl(vector bool char __a, int __b, signed char *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector bool char a, int b, unsigned char *c)
+vec_stl(vector bool char __a, int __b, unsigned char *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector bool char a, int b, vector bool char *c)
+vec_stl(vector bool char __a, int __b, vector bool char *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector short a, int b, vector short *c)
+vec_stl(vector short __a, int __b, vector short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector short a, int b, short *c)
+vec_stl(vector short __a, int __b, short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector unsigned short a, int b, vector unsigned short *c)
+vec_stl(vector unsigned short __a, int __b, vector unsigned short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector unsigned short a, int b, unsigned short *c)
+vec_stl(vector unsigned short __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector bool short a, int b, short *c)
+vec_stl(vector bool short __a, int __b, short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector bool short a, int b, unsigned short *c)
+vec_stl(vector bool short __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector bool short a, int b, vector bool short *c)
+vec_stl(vector bool short __a, int __b, vector bool short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector pixel a, int b, short *c)
+vec_stl(vector pixel __a, int __b, short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector pixel a, int b, unsigned short *c)
+vec_stl(vector pixel __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector pixel a, int b, vector pixel *c)
+vec_stl(vector pixel __a, int __b, vector pixel *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector int a, int b, vector int *c)
+vec_stl(vector int __a, int __b, vector int *__c)
 {
-  __builtin_altivec_stvxl(a, b, c);
+  __builtin_altivec_stvxl(__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector int a, int b, int *c)
+vec_stl(vector int __a, int __b, int *__c)
 {
-  __builtin_altivec_stvxl(a, b, c);
+  __builtin_altivec_stvxl(__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector unsigned int a, int b, vector unsigned int *c)
+vec_stl(vector unsigned int __a, int __b, vector unsigned int *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector unsigned int a, int b, unsigned int *c)
+vec_stl(vector unsigned int __a, int __b, unsigned int *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector bool int a, int b, int *c)
+vec_stl(vector bool int __a, int __b, int *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector bool int a, int b, unsigned int *c)
+vec_stl(vector bool int __a, int __b, unsigned int *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector bool int a, int b, vector bool int *c)
+vec_stl(vector bool int __a, int __b, vector bool int *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector float a, int b, vector float *c)
+vec_stl(vector float __a, int __b, vector float *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stl(vector float a, int b, float *c)
+vec_stl(vector float __a, int __b, float *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 /* vec_stvxl */
 
 static void __ATTRS_o_ai
-vec_stvxl(vector signed char a, int b, vector signed char *c)
+vec_stvxl(vector signed char __a, int __b, vector signed char *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector signed char a, int b, signed char *c)
+vec_stvxl(vector signed char __a, int __b, signed char *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector unsigned char a, int b, vector unsigned char *c)
+vec_stvxl(vector unsigned char __a, int __b, vector unsigned char *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector unsigned char a, int b, unsigned char *c)
+vec_stvxl(vector unsigned char __a, int __b, unsigned char *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector bool char a, int b, signed char *c)
+vec_stvxl(vector bool char __a, int __b, signed char *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector bool char a, int b, unsigned char *c)
+vec_stvxl(vector bool char __a, int __b, unsigned char *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector bool char a, int b, vector bool char *c)
+vec_stvxl(vector bool char __a, int __b, vector bool char *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector short a, int b, vector short *c)
+vec_stvxl(vector short __a, int __b, vector short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector short a, int b, short *c)
+vec_stvxl(vector short __a, int __b, short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector unsigned short a, int b, vector unsigned short *c)
+vec_stvxl(vector unsigned short __a, int __b, vector unsigned short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector unsigned short a, int b, unsigned short *c)
+vec_stvxl(vector unsigned short __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector bool short a, int b, short *c)
+vec_stvxl(vector bool short __a, int __b, short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector bool short a, int b, unsigned short *c)
+vec_stvxl(vector bool short __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector bool short a, int b, vector bool short *c)
+vec_stvxl(vector bool short __a, int __b, vector bool short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector pixel a, int b, short *c)
+vec_stvxl(vector pixel __a, int __b, short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector pixel a, int b, unsigned short *c)
+vec_stvxl(vector pixel __a, int __b, unsigned short *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector pixel a, int b, vector pixel *c)
+vec_stvxl(vector pixel __a, int __b, vector pixel *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector int a, int b, vector int *c)
+vec_stvxl(vector int __a, int __b, vector int *__c)
 {
-  __builtin_altivec_stvxl(a, b, c);
+  __builtin_altivec_stvxl(__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector int a, int b, int *c)
+vec_stvxl(vector int __a, int __b, int *__c)
 {
-  __builtin_altivec_stvxl(a, b, c);
+  __builtin_altivec_stvxl(__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector unsigned int a, int b, vector unsigned int *c)
+vec_stvxl(vector unsigned int __a, int __b, vector unsigned int *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector unsigned int a, int b, unsigned int *c)
+vec_stvxl(vector unsigned int __a, int __b, unsigned int *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector bool int a, int b, int *c)
+vec_stvxl(vector bool int __a, int __b, int *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector bool int a, int b, unsigned int *c)
+vec_stvxl(vector bool int __a, int __b, unsigned int *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector bool int a, int b, vector bool int *c)
+vec_stvxl(vector bool int __a, int __b, vector bool int *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector float a, int b, vector float *c)
+vec_stvxl(vector float __a, int __b, vector float *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvxl(vector float a, int b, float *c)
+vec_stvxl(vector float __a, int __b, float *__c)
 {
-  __builtin_altivec_stvxl((vector int)a, b, c);
+  __builtin_altivec_stvxl((vector int)__a, __b, __c);
 }
 
 /* vec_sub */
 
 static vector signed char __ATTRS_o_ai
-vec_sub(vector signed char a, vector signed char b)
+vec_sub(vector signed char __a, vector signed char __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_sub(vector bool char a, vector signed char b)
+vec_sub(vector bool char __a, vector signed char __b)
 {
-  return (vector signed char)a - b;
+  return (vector signed char)__a - __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_sub(vector signed char a, vector bool char b)
+vec_sub(vector signed char __a, vector bool char __b)
 {
-  return a - (vector signed char)b;
+  return __a - (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_sub(vector unsigned char a, vector unsigned char b)
+vec_sub(vector unsigned char __a, vector unsigned char __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_sub(vector bool char a, vector unsigned char b)
+vec_sub(vector bool char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)a - b;
+  return (vector unsigned char)__a - __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_sub(vector unsigned char a, vector bool char b)
+vec_sub(vector unsigned char __a, vector bool char __b)
 {
-  return a - (vector unsigned char)b;
+  return __a - (vector unsigned char)__b;
 }
 
 static vector short __ATTRS_o_ai
-vec_sub(vector short a, vector short b)
+vec_sub(vector short __a, vector short __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_sub(vector bool short a, vector short b)
+vec_sub(vector bool short __a, vector short __b)
 {
-  return (vector short)a - b;
+  return (vector short)__a - __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_sub(vector short a, vector bool short b)
+vec_sub(vector short __a, vector bool short __b)
 {
-  return a - (vector short)b;
+  return __a - (vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_sub(vector unsigned short a, vector unsigned short b)
+vec_sub(vector unsigned short __a, vector unsigned short __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_sub(vector bool short a, vector unsigned short b)
+vec_sub(vector bool short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)a - b;
+  return (vector unsigned short)__a - __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_sub(vector unsigned short a, vector bool short b)
+vec_sub(vector unsigned short __a, vector bool short __b)
 {
-  return a - (vector unsigned short)b;
+  return __a - (vector unsigned short)__b;
 }
 
 static vector int __ATTRS_o_ai
-vec_sub(vector int a, vector int b)
+vec_sub(vector int __a, vector int __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_sub(vector bool int a, vector int b)
+vec_sub(vector bool int __a, vector int __b)
 {
-  return (vector int)a - b;
+  return (vector int)__a - __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_sub(vector int a, vector bool int b)
+vec_sub(vector int __a, vector bool int __b)
 {
-  return a - (vector int)b;
+  return __a - (vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_sub(vector unsigned int a, vector unsigned int b)
+vec_sub(vector unsigned int __a, vector unsigned int __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_sub(vector bool int a, vector unsigned int b)
+vec_sub(vector bool int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)a - b;
+  return (vector unsigned int)__a - __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_sub(vector unsigned int a, vector bool int b)
+vec_sub(vector unsigned int __a, vector bool int __b)
 {
-  return a - (vector unsigned int)b;
+  return __a - (vector unsigned int)__b;
 }
 
 static vector float __ATTRS_o_ai
-vec_sub(vector float a, vector float b)
+vec_sub(vector float __a, vector float __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 /* vec_vsububm */
@@ -7637,39 +7637,39 @@
 #define __builtin_altivec_vsububm vec_vsububm
 
 static vector signed char __ATTRS_o_ai
-vec_vsububm(vector signed char a, vector signed char b)
+vec_vsububm(vector signed char __a, vector signed char __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vsububm(vector bool char a, vector signed char b)
+vec_vsububm(vector bool char __a, vector signed char __b)
 {
-  return (vector signed char)a - b;
+  return (vector signed char)__a - __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vsububm(vector signed char a, vector bool char b)
+vec_vsububm(vector signed char __a, vector bool char __b)
 {
-  return a - (vector signed char)b;
+  return __a - (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsububm(vector unsigned char a, vector unsigned char b)
+vec_vsububm(vector unsigned char __a, vector unsigned char __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsububm(vector bool char a, vector unsigned char b)
+vec_vsububm(vector bool char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)a - b;
+  return (vector unsigned char)__a - __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsububm(vector unsigned char a, vector bool char b)
+vec_vsububm(vector unsigned char __a, vector bool char __b)
 {
-  return a - (vector unsigned char)b;
+  return __a - (vector unsigned char)__b;
 }
 
 /* vec_vsubuhm */
@@ -7677,39 +7677,39 @@
 #define __builtin_altivec_vsubuhm vec_vsubuhm
 
 static vector short __ATTRS_o_ai
-vec_vsubuhm(vector short a, vector short b)
+vec_vsubuhm(vector short __a, vector short __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vsubuhm(vector bool short a, vector short b)
+vec_vsubuhm(vector bool short __a, vector short __b)
 {
-  return (vector short)a - b;
+  return (vector short)__a - __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vsubuhm(vector short a, vector bool short b)
+vec_vsubuhm(vector short __a, vector bool short __b)
 {
-  return a - (vector short)b;
+  return __a - (vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsubuhm(vector unsigned short a, vector unsigned short b)
+vec_vsubuhm(vector unsigned short __a, vector unsigned short __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsubuhm(vector bool short a, vector unsigned short b)
+vec_vsubuhm(vector bool short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)a - b;
+  return (vector unsigned short)__a - __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsubuhm(vector unsigned short a, vector bool short b)
+vec_vsubuhm(vector unsigned short __a, vector bool short __b)
 {
-  return a - (vector unsigned short)b;
+  return __a - (vector unsigned short)__b;
 }
 
 /* vec_vsubuwm */
@@ -7717,39 +7717,39 @@
 #define __builtin_altivec_vsubuwm vec_vsubuwm
 
 static vector int __ATTRS_o_ai
-vec_vsubuwm(vector int a, vector int b)
+vec_vsubuwm(vector int __a, vector int __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vsubuwm(vector bool int a, vector int b)
+vec_vsubuwm(vector bool int __a, vector int __b)
 {
-  return (vector int)a - b;
+  return (vector int)__a - __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vsubuwm(vector int a, vector bool int b)
+vec_vsubuwm(vector int __a, vector bool int __b)
 {
-  return a - (vector int)b;
+  return __a - (vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsubuwm(vector unsigned int a, vector unsigned int b)
+vec_vsubuwm(vector unsigned int __a, vector unsigned int __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsubuwm(vector bool int a, vector unsigned int b)
+vec_vsubuwm(vector bool int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)a - b;
+  return (vector unsigned int)__a - __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsubuwm(vector unsigned int a, vector bool int b)
+vec_vsubuwm(vector unsigned int __a, vector bool int __b)
 {
-  return a - (vector unsigned int)b;
+  return __a - (vector unsigned int)__b;
 }
 
 /* vec_vsubfp */
@@ -7757,479 +7757,479 @@
 #define __builtin_altivec_vsubfp vec_vsubfp
 
 static vector float __attribute__((__always_inline__))
-vec_vsubfp(vector float a, vector float b)
+vec_vsubfp(vector float __a, vector float __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 /* vec_subc */
 
 static vector unsigned int __attribute__((__always_inline__))
-vec_subc(vector unsigned int a, vector unsigned int b)
+vec_subc(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vsubcuw(a, b);
+  return __builtin_altivec_vsubcuw(__a, __b);
 }
 
 /* vec_vsubcuw */
 
 static vector unsigned int __attribute__((__always_inline__))
-vec_vsubcuw(vector unsigned int a, vector unsigned int b)
+vec_vsubcuw(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vsubcuw(a, b);
+  return __builtin_altivec_vsubcuw(__a, __b);
 }
 
 /* vec_subs */
 
 static vector signed char __ATTRS_o_ai
-vec_subs(vector signed char a, vector signed char b)
+vec_subs(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vsubsbs(a, b);
+  return __builtin_altivec_vsubsbs(__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_subs(vector bool char a, vector signed char b)
+vec_subs(vector bool char __a, vector signed char __b)
 {
-  return __builtin_altivec_vsubsbs((vector signed char)a, b);
+  return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_subs(vector signed char a, vector bool char b)
+vec_subs(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vsubsbs(a, (vector signed char)b);
+  return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_subs(vector unsigned char a, vector unsigned char b)
+vec_subs(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vsububs(a, b);
+  return __builtin_altivec_vsububs(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_subs(vector bool char a, vector unsigned char b)
+vec_subs(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vsububs((vector unsigned char)a, b);
+  return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_subs(vector unsigned char a, vector bool char b)
+vec_subs(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vsububs(a, (vector unsigned char)b);
+  return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_subs(vector short a, vector short b)
+vec_subs(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vsubshs(a, b);
+  return __builtin_altivec_vsubshs(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_subs(vector bool short a, vector short b)
+vec_subs(vector bool short __a, vector short __b)
 {
-  return __builtin_altivec_vsubshs((vector short)a, b);
+  return __builtin_altivec_vsubshs((vector short)__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_subs(vector short a, vector bool short b)
+vec_subs(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vsubshs(a, (vector short)b);
+  return __builtin_altivec_vsubshs(__a, (vector short)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_subs(vector unsigned short a, vector unsigned short b)
+vec_subs(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vsubuhs(a, b);
+  return __builtin_altivec_vsubuhs(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_subs(vector bool short a, vector unsigned short b)
+vec_subs(vector bool short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vsubuhs((vector unsigned short)a, b);
+  return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_subs(vector unsigned short a, vector bool short b)
+vec_subs(vector unsigned short __a, vector bool short __b)
 {
-  return __builtin_altivec_vsubuhs(a, (vector unsigned short)b);
+  return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_subs(vector int a, vector int b)
+vec_subs(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vsubsws(a, b);
+  return __builtin_altivec_vsubsws(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_subs(vector bool int a, vector int b)
+vec_subs(vector bool int __a, vector int __b)
 {
-  return __builtin_altivec_vsubsws((vector int)a, b);
+  return __builtin_altivec_vsubsws((vector int)__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_subs(vector int a, vector bool int b)
+vec_subs(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vsubsws(a, (vector int)b);
+  return __builtin_altivec_vsubsws(__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_subs(vector unsigned int a, vector unsigned int b)
+vec_subs(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vsubuws(a, b);
+  return __builtin_altivec_vsubuws(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_subs(vector bool int a, vector unsigned int b)
+vec_subs(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vsubuws((vector unsigned int)a, b);
+  return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_subs(vector unsigned int a, vector bool int b)
+vec_subs(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vsubuws(a, (vector unsigned int)b);
+  return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
 }
 
 /* vec_vsubsbs */
 
 static vector signed char __ATTRS_o_ai
-vec_vsubsbs(vector signed char a, vector signed char b)
+vec_vsubsbs(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vsubsbs(a, b);
+  return __builtin_altivec_vsubsbs(__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vsubsbs(vector bool char a, vector signed char b)
+vec_vsubsbs(vector bool char __a, vector signed char __b)
 {
-  return __builtin_altivec_vsubsbs((vector signed char)a, b);
+  return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vsubsbs(vector signed char a, vector bool char b)
+vec_vsubsbs(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vsubsbs(a, (vector signed char)b);
+  return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
 }
 
 /* vec_vsububs */
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsububs(vector unsigned char a, vector unsigned char b)
+vec_vsububs(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vsububs(a, b);
+  return __builtin_altivec_vsububs(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsububs(vector bool char a, vector unsigned char b)
+vec_vsububs(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vsububs((vector unsigned char)a, b);
+  return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vsububs(vector unsigned char a, vector bool char b)
+vec_vsububs(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vsububs(a, (vector unsigned char)b);
+  return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
 }
 
 /* vec_vsubshs */
 
 static vector short __ATTRS_o_ai
-vec_vsubshs(vector short a, vector short b)
+vec_vsubshs(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vsubshs(a, b);
+  return __builtin_altivec_vsubshs(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vsubshs(vector bool short a, vector short b)
+vec_vsubshs(vector bool short __a, vector short __b)
 {
-  return __builtin_altivec_vsubshs((vector short)a, b);
+  return __builtin_altivec_vsubshs((vector short)__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vsubshs(vector short a, vector bool short b)
+vec_vsubshs(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vsubshs(a, (vector short)b);
+  return __builtin_altivec_vsubshs(__a, (vector short)__b);
 }
 
 /* vec_vsubuhs */
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsubuhs(vector unsigned short a, vector unsigned short b)
+vec_vsubuhs(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vsubuhs(a, b);
+  return __builtin_altivec_vsubuhs(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsubuhs(vector bool short a, vector unsigned short b)
+vec_vsubuhs(vector bool short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vsubuhs((vector unsigned short)a, b);
+  return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vsubuhs(vector unsigned short a, vector bool short b)
+vec_vsubuhs(vector unsigned short __a, vector bool short __b)
 {
-  return __builtin_altivec_vsubuhs(a, (vector unsigned short)b);
+  return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
 }
 
 /* vec_vsubsws */
 
 static vector int __ATTRS_o_ai
-vec_vsubsws(vector int a, vector int b)
+vec_vsubsws(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vsubsws(a, b);
+  return __builtin_altivec_vsubsws(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vsubsws(vector bool int a, vector int b)
+vec_vsubsws(vector bool int __a, vector int __b)
 {
-  return __builtin_altivec_vsubsws((vector int)a, b);
+  return __builtin_altivec_vsubsws((vector int)__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vsubsws(vector int a, vector bool int b)
+vec_vsubsws(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vsubsws(a, (vector int)b);
+  return __builtin_altivec_vsubsws(__a, (vector int)__b);
 }
 
 /* vec_vsubuws */
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsubuws(vector unsigned int a, vector unsigned int b)
+vec_vsubuws(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vsubuws(a, b);
+  return __builtin_altivec_vsubuws(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsubuws(vector bool int a, vector unsigned int b)
+vec_vsubuws(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vsubuws((vector unsigned int)a, b);
+  return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vsubuws(vector unsigned int a, vector bool int b)
+vec_vsubuws(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vsubuws(a, (vector unsigned int)b);
+  return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
 }
 
 /* vec_sum4s */
 
 static vector int __ATTRS_o_ai
-vec_sum4s(vector signed char a, vector int b)
+vec_sum4s(vector signed char __a, vector int __b)
 {
-  return __builtin_altivec_vsum4sbs(a, b);
+  return __builtin_altivec_vsum4sbs(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_sum4s(vector unsigned char a, vector unsigned int b)
+vec_sum4s(vector unsigned char __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vsum4ubs(a, b);
+  return __builtin_altivec_vsum4ubs(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_sum4s(vector signed short a, vector int b)
+vec_sum4s(vector signed short __a, vector int __b)
 {
-  return __builtin_altivec_vsum4shs(a, b);
+  return __builtin_altivec_vsum4shs(__a, __b);
 }
 
 /* vec_vsum4sbs */
 
 static vector int __attribute__((__always_inline__))
-vec_vsum4sbs(vector signed char a, vector int b)
+vec_vsum4sbs(vector signed char __a, vector int __b)
 {
-  return __builtin_altivec_vsum4sbs(a, b);
+  return __builtin_altivec_vsum4sbs(__a, __b);
 }
 
 /* vec_vsum4ubs */
 
 static vector unsigned int __attribute__((__always_inline__))
-vec_vsum4ubs(vector unsigned char a, vector unsigned int b)
+vec_vsum4ubs(vector unsigned char __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vsum4ubs(a, b);
+  return __builtin_altivec_vsum4ubs(__a, __b);
 }
 
 /* vec_vsum4shs */
 
 static vector int __attribute__((__always_inline__))
-vec_vsum4shs(vector signed short a, vector int b)
+vec_vsum4shs(vector signed short __a, vector int __b)
 {
-  return __builtin_altivec_vsum4shs(a, b);
+  return __builtin_altivec_vsum4shs(__a, __b);
 }
 
 /* vec_sum2s */
 
 static vector signed int __attribute__((__always_inline__))
-vec_sum2s(vector int a, vector int b)
+vec_sum2s(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vsum2sws(a, b);
+  return __builtin_altivec_vsum2sws(__a, __b);
 }
 
 /* vec_vsum2sws */
 
 static vector signed int __attribute__((__always_inline__))
-vec_vsum2sws(vector int a, vector int b)
+vec_vsum2sws(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vsum2sws(a, b);
+  return __builtin_altivec_vsum2sws(__a, __b);
 }
 
 /* vec_sums */
 
 static vector signed int __attribute__((__always_inline__))
-vec_sums(vector signed int a, vector signed int b)
+vec_sums(vector signed int __a, vector signed int __b)
 {
-  return __builtin_altivec_vsumsws(a, b);
+  return __builtin_altivec_vsumsws(__a, __b);
 }
 
 /* vec_vsumsws */
 
 static vector signed int __attribute__((__always_inline__))
-vec_vsumsws(vector signed int a, vector signed int b)
+vec_vsumsws(vector signed int __a, vector signed int __b)
 {
-  return __builtin_altivec_vsumsws(a, b);
+  return __builtin_altivec_vsumsws(__a, __b);
 }
 
 /* vec_trunc */
 
 static vector float __attribute__((__always_inline__))
-vec_trunc(vector float a)
+vec_trunc(vector float __a)
 {
-  return __builtin_altivec_vrfiz(a);
+  return __builtin_altivec_vrfiz(__a);
 }
 
 /* vec_vrfiz */
 
 static vector float __attribute__((__always_inline__))
-vec_vrfiz(vector float a)
+vec_vrfiz(vector float __a)
 {
-  return __builtin_altivec_vrfiz(a);
+  return __builtin_altivec_vrfiz(__a);
 }
 
 /* vec_unpackh */
 
 static vector short __ATTRS_o_ai
-vec_unpackh(vector signed char a)
+vec_unpackh(vector signed char __a)
 {
-  return __builtin_altivec_vupkhsb((vector char)a);
+  return __builtin_altivec_vupkhsb((vector char)__a);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_unpackh(vector bool char a)
+vec_unpackh(vector bool char __a)
 {
-  return (vector bool short)__builtin_altivec_vupkhsb((vector char)a);
+  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
 }
 
 static vector int __ATTRS_o_ai
-vec_unpackh(vector short a)
+vec_unpackh(vector short __a)
 {
-  return __builtin_altivec_vupkhsh(a);
+  return __builtin_altivec_vupkhsh(__a);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_unpackh(vector bool short a)
+vec_unpackh(vector bool short __a)
 {
-  return (vector bool int)__builtin_altivec_vupkhsh((vector short)a);
+  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_unpackh(vector pixel a)
+vec_unpackh(vector pixel __a)
 {
-  return (vector unsigned int)__builtin_altivec_vupkhsh((vector short)a);
+  return (vector unsigned int)__builtin_altivec_vupkhsh((vector short)__a);
 }
 
 /* vec_vupkhsb */
 
 static vector short __ATTRS_o_ai
-vec_vupkhsb(vector signed char a)
+vec_vupkhsb(vector signed char __a)
 {
-  return __builtin_altivec_vupkhsb((vector char)a);
+  return __builtin_altivec_vupkhsb((vector char)__a);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vupkhsb(vector bool char a)
+vec_vupkhsb(vector bool char __a)
 {
-  return (vector bool short)__builtin_altivec_vupkhsb((vector char)a);
+  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
 }
 
 /* vec_vupkhsh */
 
 static vector int __ATTRS_o_ai
-vec_vupkhsh(vector short a)
+vec_vupkhsh(vector short __a)
 {
-  return __builtin_altivec_vupkhsh(a);
+  return __builtin_altivec_vupkhsh(__a);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vupkhsh(vector bool short a)
+vec_vupkhsh(vector bool short __a)
 {
-  return (vector bool int)__builtin_altivec_vupkhsh((vector short)a);
+  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vupkhsh(vector pixel a)
+vec_vupkhsh(vector pixel __a)
 {
-  return (vector unsigned int)__builtin_altivec_vupkhsh((vector short)a);
+  return (vector unsigned int)__builtin_altivec_vupkhsh((vector short)__a);
 }
 
 /* vec_unpackl */
 
 static vector short __ATTRS_o_ai
-vec_unpackl(vector signed char a)
+vec_unpackl(vector signed char __a)
 {
-  return __builtin_altivec_vupklsb((vector char)a);
+  return __builtin_altivec_vupklsb((vector char)__a);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_unpackl(vector bool char a)
+vec_unpackl(vector bool char __a)
 {
-  return (vector bool short)__builtin_altivec_vupklsb((vector char)a);
+  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
 }
 
 static vector int __ATTRS_o_ai
-vec_unpackl(vector short a)
+vec_unpackl(vector short __a)
 {
-  return __builtin_altivec_vupklsh(a);
+  return __builtin_altivec_vupklsh(__a);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_unpackl(vector bool short a)
+vec_unpackl(vector bool short __a)
 {
-  return (vector bool int)__builtin_altivec_vupklsh((vector short)a);
+  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_unpackl(vector pixel a)
+vec_unpackl(vector pixel __a)
 {
-  return (vector unsigned int)__builtin_altivec_vupklsh((vector short)a);
+  return (vector unsigned int)__builtin_altivec_vupklsh((vector short)__a);
 }
 
 /* vec_vupklsb */
 
 static vector short __ATTRS_o_ai
-vec_vupklsb(vector signed char a)
+vec_vupklsb(vector signed char __a)
 {
-  return __builtin_altivec_vupklsb((vector char)a);
+  return __builtin_altivec_vupklsb((vector char)__a);
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vupklsb(vector bool char a)
+vec_vupklsb(vector bool char __a)
 {
-  return (vector bool short)__builtin_altivec_vupklsb((vector char)a);
+  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
 }
 
 /* vec_vupklsh */
 
 static vector int __ATTRS_o_ai
-vec_vupklsh(vector short a)
+vec_vupklsh(vector short __a)
 {
-  return __builtin_altivec_vupklsh(a);
+  return __builtin_altivec_vupklsh(__a);
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vupklsh(vector bool short a)
+vec_vupklsh(vector bool short __a)
 {
-  return (vector bool int)__builtin_altivec_vupklsh((vector short)a);
+  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vupklsh(vector pixel a)
+vec_vupklsh(vector pixel __a)
 {
-  return (vector unsigned int)__builtin_altivec_vupklsh((vector short)a);
+  return (vector unsigned int)__builtin_altivec_vupklsh((vector short)__a);
 }
 
 /* vec_xor */
@@ -8237,299 +8237,299 @@
 #define __builtin_altivec_vxor vec_xor
 
 static vector signed char __ATTRS_o_ai
-vec_xor(vector signed char a, vector signed char b)
+vec_xor(vector signed char __a, vector signed char __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_xor(vector bool char a, vector signed char b)
+vec_xor(vector bool char __a, vector signed char __b)
 {
-  return (vector signed char)a ^ b;
+  return (vector signed char)__a ^ __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_xor(vector signed char a, vector bool char b)
+vec_xor(vector signed char __a, vector bool char __b)
 {
-  return a ^ (vector signed char)b;
+  return __a ^ (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_xor(vector unsigned char a, vector unsigned char b)
+vec_xor(vector unsigned char __a, vector unsigned char __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_xor(vector bool char a, vector unsigned char b)
+vec_xor(vector bool char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)a ^ b;
+  return (vector unsigned char)__a ^ __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_xor(vector unsigned char a, vector bool char b)
+vec_xor(vector unsigned char __a, vector bool char __b)
 {
-  return a ^ (vector unsigned char)b;
+  return __a ^ (vector unsigned char)__b;
 }
 
 static vector bool char __ATTRS_o_ai
-vec_xor(vector bool char a, vector bool char b)
+vec_xor(vector bool char __a, vector bool char __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_xor(vector short a, vector short b)
+vec_xor(vector short __a, vector short __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_xor(vector bool short a, vector short b)
+vec_xor(vector bool short __a, vector short __b)
 {
-  return (vector short)a ^ b;
+  return (vector short)__a ^ __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_xor(vector short a, vector bool short b)
+vec_xor(vector short __a, vector bool short __b)
 {
-  return a ^ (vector short)b;
+  return __a ^ (vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_xor(vector unsigned short a, vector unsigned short b)
+vec_xor(vector unsigned short __a, vector unsigned short __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_xor(vector bool short a, vector unsigned short b)
+vec_xor(vector bool short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)a ^ b;
+  return (vector unsigned short)__a ^ __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_xor(vector unsigned short a, vector bool short b)
+vec_xor(vector unsigned short __a, vector bool short __b)
 {
-  return a ^ (vector unsigned short)b;
+  return __a ^ (vector unsigned short)__b;
 }
 
 static vector bool short __ATTRS_o_ai
-vec_xor(vector bool short a, vector bool short b)
+vec_xor(vector bool short __a, vector bool short __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_xor(vector int a, vector int b)
+vec_xor(vector int __a, vector int __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_xor(vector bool int a, vector int b)
+vec_xor(vector bool int __a, vector int __b)
 {
-  return (vector int)a ^ b;
+  return (vector int)__a ^ __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_xor(vector int a, vector bool int b)
+vec_xor(vector int __a, vector bool int __b)
 {
-  return a ^ (vector int)b;
+  return __a ^ (vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_xor(vector unsigned int a, vector unsigned int b)
+vec_xor(vector unsigned int __a, vector unsigned int __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_xor(vector bool int a, vector unsigned int b)
+vec_xor(vector bool int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)a ^ b;
+  return (vector unsigned int)__a ^ __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_xor(vector unsigned int a, vector bool int b)
+vec_xor(vector unsigned int __a, vector bool int __b)
 {
-  return a ^ (vector unsigned int)b;
+  return __a ^ (vector unsigned int)__b;
 }
 
 static vector bool int __ATTRS_o_ai
-vec_xor(vector bool int a, vector bool int b)
+vec_xor(vector bool int __a, vector bool int __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector float __ATTRS_o_ai
-vec_xor(vector float a, vector float b)
+vec_xor(vector float __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a ^ (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a ^ (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_xor(vector bool int a, vector float b)
+vec_xor(vector bool int __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a ^ (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a ^ (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_xor(vector float a, vector bool int b)
+vec_xor(vector float __a, vector bool int __b)
 {
-  vector unsigned int res = (vector unsigned int)a ^ (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a ^ (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 /* vec_vxor */
 
 static vector signed char __ATTRS_o_ai
-vec_vxor(vector signed char a, vector signed char b)
+vec_vxor(vector signed char __a, vector signed char __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vxor(vector bool char a, vector signed char b)
+vec_vxor(vector bool char __a, vector signed char __b)
 {
-  return (vector signed char)a ^ b;
+  return (vector signed char)__a ^ __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vxor(vector signed char a, vector bool char b)
+vec_vxor(vector signed char __a, vector bool char __b)
 {
-  return a ^ (vector signed char)b;
+  return __a ^ (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vxor(vector unsigned char a, vector unsigned char b)
+vec_vxor(vector unsigned char __a, vector unsigned char __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vxor(vector bool char a, vector unsigned char b)
+vec_vxor(vector bool char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)a ^ b;
+  return (vector unsigned char)__a ^ __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vxor(vector unsigned char a, vector bool char b)
+vec_vxor(vector unsigned char __a, vector bool char __b)
 {
-  return a ^ (vector unsigned char)b;
+  return __a ^ (vector unsigned char)__b;
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vxor(vector bool char a, vector bool char b)
+vec_vxor(vector bool char __a, vector bool char __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vxor(vector short a, vector short b)
+vec_vxor(vector short __a, vector short __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vxor(vector bool short a, vector short b)
+vec_vxor(vector bool short __a, vector short __b)
 {
-  return (vector short)a ^ b;
+  return (vector short)__a ^ __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vxor(vector short a, vector bool short b)
+vec_vxor(vector short __a, vector bool short __b)
 {
-  return a ^ (vector short)b;
+  return __a ^ (vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vxor(vector unsigned short a, vector unsigned short b)
+vec_vxor(vector unsigned short __a, vector unsigned short __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vxor(vector bool short a, vector unsigned short b)
+vec_vxor(vector bool short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)a ^ b;
+  return (vector unsigned short)__a ^ __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vxor(vector unsigned short a, vector bool short b)
+vec_vxor(vector unsigned short __a, vector bool short __b)
 {
-  return a ^ (vector unsigned short)b;
+  return __a ^ (vector unsigned short)__b;
 }
 
 static vector bool short __ATTRS_o_ai
-vec_vxor(vector bool short a, vector bool short b)
+vec_vxor(vector bool short __a, vector bool short __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vxor(vector int a, vector int b)
+vec_vxor(vector int __a, vector int __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vxor(vector bool int a, vector int b)
+vec_vxor(vector bool int __a, vector int __b)
 {
-  return (vector int)a ^ b;
+  return (vector int)__a ^ __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vxor(vector int a, vector bool int b)
+vec_vxor(vector int __a, vector bool int __b)
 {
-  return a ^ (vector int)b;
+  return __a ^ (vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vxor(vector unsigned int a, vector unsigned int b)
+vec_vxor(vector unsigned int __a, vector unsigned int __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vxor(vector bool int a, vector unsigned int b)
+vec_vxor(vector bool int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)a ^ b;
+  return (vector unsigned int)__a ^ __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vxor(vector unsigned int a, vector bool int b)
+vec_vxor(vector unsigned int __a, vector bool int __b)
 {
-  return a ^ (vector unsigned int)b;
+  return __a ^ (vector unsigned int)__b;
 }
 
 static vector bool int __ATTRS_o_ai
-vec_vxor(vector bool int a, vector bool int b)
+vec_vxor(vector bool int __a, vector bool int __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static vector float __ATTRS_o_ai
-vec_vxor(vector float a, vector float b)
+vec_vxor(vector float __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a ^ (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a ^ (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_vxor(vector bool int a, vector float b)
+vec_vxor(vector bool int __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a ^ (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a ^ (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_vxor(vector float a, vector bool int b)
+vec_vxor(vector float __a, vector bool int __b)
 {
-  vector unsigned int res = (vector unsigned int)a ^ (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a ^ (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 /* ------------------------ extensions for CBEA ----------------------------- */
@@ -8537,1402 +8537,1402 @@
 /* vec_extract */
 
 static signed char __ATTRS_o_ai
-vec_extract(vector signed char a, int b)
+vec_extract(vector signed char __a, int __b)
 {
-  return a[b];
+  return __a[__b];
 }
 
 static unsigned char __ATTRS_o_ai
-vec_extract(vector unsigned char a, int b)
+vec_extract(vector unsigned char __a, int __b)
 {
-  return a[b];
+  return __a[__b];
 }
 
 static short __ATTRS_o_ai
-vec_extract(vector short a, int b)
+vec_extract(vector short __a, int __b)
 {
-  return a[b];
+  return __a[__b];
 }
 
 static unsigned short __ATTRS_o_ai
-vec_extract(vector unsigned short a, int b)
+vec_extract(vector unsigned short __a, int __b)
 {
-  return a[b];
+  return __a[__b];
 }
 
 static int __ATTRS_o_ai
-vec_extract(vector int a, int b)
+vec_extract(vector int __a, int __b)
 {
-  return a[b];
+  return __a[__b];
 }
 
 static unsigned int __ATTRS_o_ai
-vec_extract(vector unsigned int a, int b)
+vec_extract(vector unsigned int __a, int __b)
 {
-  return a[b];
+  return __a[__b];
 }
 
 static float __ATTRS_o_ai
-vec_extract(vector float a, int b)
+vec_extract(vector float __a, int __b)
 {
-  return a[b];
+  return __a[__b];
 }
 
 /* vec_insert */
 
 static vector signed char __ATTRS_o_ai
-vec_insert(signed char a, vector signed char b, int c)
+vec_insert(signed char __a, vector signed char __b, int __c)
 {
-  b[c] = a;
-  return b;
+  __b[__c] = __a;
+  return __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_insert(unsigned char a, vector unsigned char b, int c)
+vec_insert(unsigned char __a, vector unsigned char __b, int __c)
 {
-  b[c] = a;
-  return b;
+  __b[__c] = __a;
+  return __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_insert(short a, vector short b, int c)
+vec_insert(short __a, vector short __b, int __c)
 {
-  b[c] = a;
-  return b;
+  __b[__c] = __a;
+  return __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_insert(unsigned short a, vector unsigned short b, int c)
+vec_insert(unsigned short __a, vector unsigned short __b, int __c)
 {
-  b[c] = a;
-  return b;
+  __b[__c] = __a;
+  return __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_insert(int a, vector int b, int c)
+vec_insert(int __a, vector int __b, int __c)
 {
-  b[c] = a;
-  return b;
+  __b[__c] = __a;
+  return __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_insert(unsigned int a, vector unsigned int b, int c)
+vec_insert(unsigned int __a, vector unsigned int __b, int __c)
 {
-  b[c] = a;
-  return b;
+  __b[__c] = __a;
+  return __b;
 }
 
 static vector float __ATTRS_o_ai
-vec_insert(float a, vector float b, int c)
+vec_insert(float __a, vector float __b, int __c)
 {
-  b[c] = a;
-  return b;
+  __b[__c] = __a;
+  return __b;
 }
 
 /* vec_lvlx */
 
 static vector signed char __ATTRS_o_ai
-vec_lvlx(int a, const signed char *b)
+vec_lvlx(int __a, const signed char *__b)
 {
-  return vec_perm(vec_ld(a, b),
+  return vec_perm(vec_ld(__a, __b),
                   (vector signed char)(0),
-                  vec_lvsl(a, b));
+                  vec_lvsl(__a, __b));
 }
 
 static vector signed char __ATTRS_o_ai
-vec_lvlx(int a, const vector signed char *b)
+vec_lvlx(int __a, const vector signed char *__b)
 {
-  return vec_perm(vec_ld(a, b), 
+  return vec_perm(vec_ld(__a, __b),
                   (vector signed char)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvlx(int a, const unsigned char *b)
+vec_lvlx(int __a, const unsigned char *__b)
 {
-  return vec_perm(vec_ld(a, b),
+  return vec_perm(vec_ld(__a, __b),
                   (vector unsigned char)(0),
-                  vec_lvsl(a, b));
+                  vec_lvsl(__a, __b));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvlx(int a, const vector unsigned char *b)
+vec_lvlx(int __a, const vector unsigned char *__b)
 {
-  return vec_perm(vec_ld(a, b), 
+  return vec_perm(vec_ld(__a, __b),
                   (vector unsigned char)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector bool char __ATTRS_o_ai
-vec_lvlx(int a, const vector bool char *b)
+vec_lvlx(int __a, const vector bool char *__b)
 {
-  return vec_perm(vec_ld(a, b), 
+  return vec_perm(vec_ld(__a, __b),
                   (vector bool char)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector short __ATTRS_o_ai
-vec_lvlx(int a, const short *b)
+vec_lvlx(int __a, const short *__b)
 {
-  return vec_perm(vec_ld(a, b),
+  return vec_perm(vec_ld(__a, __b),
                   (vector short)(0),
-                  vec_lvsl(a, b));
+                  vec_lvsl(__a, __b));
 }
 
 static vector short __ATTRS_o_ai
-vec_lvlx(int a, const vector short *b)
+vec_lvlx(int __a, const vector short *__b)
 {
-  return vec_perm(vec_ld(a, b),
+  return vec_perm(vec_ld(__a, __b),
                   (vector short)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_lvlx(int a, const unsigned short *b)
+vec_lvlx(int __a, const unsigned short *__b)
 {
-  return vec_perm(vec_ld(a, b),
+  return vec_perm(vec_ld(__a, __b),
                   (vector unsigned short)(0),
-                  vec_lvsl(a, b));
+                  vec_lvsl(__a, __b));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_lvlx(int a, const vector unsigned short *b)
+vec_lvlx(int __a, const vector unsigned short *__b)
 {
-  return vec_perm(vec_ld(a, b), 
+  return vec_perm(vec_ld(__a, __b),
                   (vector unsigned short)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector bool short __ATTRS_o_ai
-vec_lvlx(int a, const vector bool short *b)
+vec_lvlx(int __a, const vector bool short *__b)
 {
-  return vec_perm(vec_ld(a, b), 
+  return vec_perm(vec_ld(__a, __b),
                   (vector bool short)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector pixel __ATTRS_o_ai
-vec_lvlx(int a, const vector pixel *b)
+vec_lvlx(int __a, const vector pixel *__b)
 {
-  return vec_perm(vec_ld(a, b), 
+  return vec_perm(vec_ld(__a, __b),
                   (vector pixel)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector int __ATTRS_o_ai
-vec_lvlx(int a, const int *b)
+vec_lvlx(int __a, const int *__b)
 {
-  return vec_perm(vec_ld(a, b),
+  return vec_perm(vec_ld(__a, __b),
                   (vector int)(0),
-                  vec_lvsl(a, b));
+                  vec_lvsl(__a, __b));
 }
 
 static vector int __ATTRS_o_ai
-vec_lvlx(int a, const vector int *b)
+vec_lvlx(int __a, const vector int *__b)
 {
-  return vec_perm(vec_ld(a, b),
+  return vec_perm(vec_ld(__a, __b),
                   (vector int)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_lvlx(int a, const unsigned int *b)
+vec_lvlx(int __a, const unsigned int *__b)
 {
-  return vec_perm(vec_ld(a, b),
+  return vec_perm(vec_ld(__a, __b),
                   (vector unsigned int)(0),
-                  vec_lvsl(a, b));
+                  vec_lvsl(__a, __b));
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_lvlx(int a, const vector unsigned int *b)
+vec_lvlx(int __a, const vector unsigned int *__b)
 {
-  return vec_perm(vec_ld(a, b), 
+  return vec_perm(vec_ld(__a, __b),
                   (vector unsigned int)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector bool int __ATTRS_o_ai
-vec_lvlx(int a, const vector bool int *b)
+vec_lvlx(int __a, const vector bool int *__b)
 {
-  return vec_perm(vec_ld(a, b), 
+  return vec_perm(vec_ld(__a, __b),
                   (vector bool int)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector float __ATTRS_o_ai
-vec_lvlx(int a, const float *b)
+vec_lvlx(int __a, const float *__b)
 {
-  return vec_perm(vec_ld(a, b),
+  return vec_perm(vec_ld(__a, __b),
                   (vector float)(0),
-                  vec_lvsl(a, b));
+                  vec_lvsl(__a, __b));
 }
 
 static vector float __ATTRS_o_ai
-vec_lvlx(int a, const vector float *b)
+vec_lvlx(int __a, const vector float *__b)
 {
-  return vec_perm(vec_ld(a, b),
+  return vec_perm(vec_ld(__a, __b),
                   (vector float)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 /* vec_lvlxl */
 
 static vector signed char __ATTRS_o_ai
-vec_lvlxl(int a, const signed char *b)
+vec_lvlxl(int __a, const signed char *__b)
 {
-  return vec_perm(vec_ldl(a, b),
+  return vec_perm(vec_ldl(__a, __b),
                   (vector signed char)(0),
-                  vec_lvsl(a, b));
+                  vec_lvsl(__a, __b));
 }
 
 static vector signed char __ATTRS_o_ai
-vec_lvlxl(int a, const vector signed char *b)
+vec_lvlxl(int __a, const vector signed char *__b)
 {
-  return vec_perm(vec_ldl(a, b), 
+  return vec_perm(vec_ldl(__a, __b),
                   (vector signed char)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvlxl(int a, const unsigned char *b)
+vec_lvlxl(int __a, const unsigned char *__b)
 {
-  return vec_perm(vec_ldl(a, b),
+  return vec_perm(vec_ldl(__a, __b),
                   (vector unsigned char)(0),
-                  vec_lvsl(a, b));
+                  vec_lvsl(__a, __b));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvlxl(int a, const vector unsigned char *b)
+vec_lvlxl(int __a, const vector unsigned char *__b)
 {
-  return vec_perm(vec_ldl(a, b), 
+  return vec_perm(vec_ldl(__a, __b),
                   (vector unsigned char)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector bool char __ATTRS_o_ai
-vec_lvlxl(int a, const vector bool char *b)
+vec_lvlxl(int __a, const vector bool char *__b)
 {
-  return vec_perm(vec_ldl(a, b), 
+  return vec_perm(vec_ldl(__a, __b),
                   (vector bool char)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector short __ATTRS_o_ai
-vec_lvlxl(int a, const short *b)
+vec_lvlxl(int __a, const short *__b)
 {
-  return vec_perm(vec_ldl(a, b),
+  return vec_perm(vec_ldl(__a, __b),
                   (vector short)(0),
-                  vec_lvsl(a, b));
+                  vec_lvsl(__a, __b));
 }
 
 static vector short __ATTRS_o_ai
-vec_lvlxl(int a, const vector short *b)
+vec_lvlxl(int __a, const vector short *__b)
 {
-  return vec_perm(vec_ldl(a, b),
+  return vec_perm(vec_ldl(__a, __b),
                   (vector short)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_lvlxl(int a, const unsigned short *b)
+vec_lvlxl(int __a, const unsigned short *__b)
 {
-  return vec_perm(vec_ldl(a, b),
+  return vec_perm(vec_ldl(__a, __b),
                   (vector unsigned short)(0),
-                  vec_lvsl(a, b));
+                  vec_lvsl(__a, __b));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_lvlxl(int a, const vector unsigned short *b)
+vec_lvlxl(int __a, const vector unsigned short *__b)
 {
-  return vec_perm(vec_ldl(a, b), 
+  return vec_perm(vec_ldl(__a, __b),
                   (vector unsigned short)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector bool short __ATTRS_o_ai
-vec_lvlxl(int a, const vector bool short *b)
+vec_lvlxl(int __a, const vector bool short *__b)
 {
-  return vec_perm(vec_ldl(a, b), 
+  return vec_perm(vec_ldl(__a, __b),
                   (vector bool short)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector pixel __ATTRS_o_ai
-vec_lvlxl(int a, const vector pixel *b)
+vec_lvlxl(int __a, const vector pixel *__b)
 {
-  return vec_perm(vec_ldl(a, b), 
+  return vec_perm(vec_ldl(__a, __b),
                   (vector pixel)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector int __ATTRS_o_ai
-vec_lvlxl(int a, const int *b)
+vec_lvlxl(int __a, const int *__b)
 {
-  return vec_perm(vec_ldl(a, b),
+  return vec_perm(vec_ldl(__a, __b),
                   (vector int)(0),
-                  vec_lvsl(a, b));
+                  vec_lvsl(__a, __b));
 }
 
 static vector int __ATTRS_o_ai
-vec_lvlxl(int a, const vector int *b)
+vec_lvlxl(int __a, const vector int *__b)
 {
-  return vec_perm(vec_ldl(a, b),
+  return vec_perm(vec_ldl(__a, __b),
                   (vector int)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_lvlxl(int a, const unsigned int *b)
+vec_lvlxl(int __a, const unsigned int *__b)
 {
-  return vec_perm(vec_ldl(a, b),
+  return vec_perm(vec_ldl(__a, __b),
                   (vector unsigned int)(0),
-                  vec_lvsl(a, b));
+                  vec_lvsl(__a, __b));
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_lvlxl(int a, const vector unsigned int *b)
+vec_lvlxl(int __a, const vector unsigned int *__b)
 {
-  return vec_perm(vec_ldl(a, b), 
+  return vec_perm(vec_ldl(__a, __b),
                   (vector unsigned int)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector bool int __ATTRS_o_ai
-vec_lvlxl(int a, const vector bool int *b)
+vec_lvlxl(int __a, const vector bool int *__b)
 {
-  return vec_perm(vec_ldl(a, b), 
+  return vec_perm(vec_ldl(__a, __b),
                   (vector bool int)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector float __ATTRS_o_ai
-vec_lvlxl(int a, const float *b)
+vec_lvlxl(int __a, const float *__b)
 {
-  return vec_perm(vec_ldl(a, b),
+  return vec_perm(vec_ldl(__a, __b),
                   (vector float)(0),
-                  vec_lvsl(a, b));
+                  vec_lvsl(__a, __b));
 }
 
 static vector float __ATTRS_o_ai
-vec_lvlxl(int a, vector float *b)
+vec_lvlxl(int __a, vector float *__b)
 {
-  return vec_perm(vec_ldl(a, b),
+  return vec_perm(vec_ldl(__a, __b),
                   (vector float)(0),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 /* vec_lvrx */
 
 static vector signed char __ATTRS_o_ai
-vec_lvrx(int a, const signed char *b)
+vec_lvrx(int __a, const signed char *__b)
 {
   return vec_perm((vector signed char)(0),
-                  vec_ld(a, b),
-                  vec_lvsl(a, b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, __b));
 }
 
 static vector signed char __ATTRS_o_ai
-vec_lvrx(int a, const vector signed char *b)
+vec_lvrx(int __a, const vector signed char *__b)
 {
   return vec_perm((vector signed char)(0),
-                  vec_ld(a, b), 
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvrx(int a, const unsigned char *b)
+vec_lvrx(int __a, const unsigned char *__b)
 {
   return vec_perm((vector unsigned char)(0),
-                  vec_ld(a, b),
-                  vec_lvsl(a, b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, __b));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvrx(int a, const vector unsigned char *b)
+vec_lvrx(int __a, const vector unsigned char *__b)
 {
   return vec_perm((vector unsigned char)(0),
-                  vec_ld(a, b), 
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector bool char __ATTRS_o_ai
-vec_lvrx(int a, const vector bool char *b)
+vec_lvrx(int __a, const vector bool char *__b)
 {
   return vec_perm((vector bool char)(0),
-                  vec_ld(a, b), 
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector short __ATTRS_o_ai
-vec_lvrx(int a, const short *b)
+vec_lvrx(int __a, const short *__b)
 {
   return vec_perm((vector short)(0),
-                  vec_ld(a, b),
-                  vec_lvsl(a, b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, __b));
 }
 
 static vector short __ATTRS_o_ai
-vec_lvrx(int a, const vector short *b)
+vec_lvrx(int __a, const vector short *__b)
 {
   return vec_perm((vector short)(0),
-                  vec_ld(a, b),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_lvrx(int a, const unsigned short *b)
+vec_lvrx(int __a, const unsigned short *__b)
 {
   return vec_perm((vector unsigned short)(0),
-                  vec_ld(a, b),
-                  vec_lvsl(a, b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, __b));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_lvrx(int a, const vector unsigned short *b)
+vec_lvrx(int __a, const vector unsigned short *__b)
 {
   return vec_perm((vector unsigned short)(0),
-                  vec_ld(a, b), 
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector bool short __ATTRS_o_ai
-vec_lvrx(int a, const vector bool short *b)
+vec_lvrx(int __a, const vector bool short *__b)
 {
   return vec_perm((vector bool short)(0),
-                  vec_ld(a, b), 
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector pixel __ATTRS_o_ai
-vec_lvrx(int a, const vector pixel *b)
+vec_lvrx(int __a, const vector pixel *__b)
 {
   return vec_perm((vector pixel)(0),
-                  vec_ld(a, b), 
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector int __ATTRS_o_ai
-vec_lvrx(int a, const int *b)
+vec_lvrx(int __a, const int *__b)
 {
   return vec_perm((vector int)(0),
-                  vec_ld(a, b),
-                  vec_lvsl(a, b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, __b));
 }
 
 static vector int __ATTRS_o_ai
-vec_lvrx(int a, const vector int *b)
+vec_lvrx(int __a, const vector int *__b)
 {
   return vec_perm((vector int)(0),
-                  vec_ld(a, b),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_lvrx(int a, const unsigned int *b)
+vec_lvrx(int __a, const unsigned int *__b)
 {
   return vec_perm((vector unsigned int)(0),
-                  vec_ld(a, b),
-                  vec_lvsl(a, b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, __b));
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_lvrx(int a, const vector unsigned int *b)
+vec_lvrx(int __a, const vector unsigned int *__b)
 {
   return vec_perm((vector unsigned int)(0),
-                  vec_ld(a, b), 
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector bool int __ATTRS_o_ai
-vec_lvrx(int a, const vector bool int *b)
+vec_lvrx(int __a, const vector bool int *__b)
 {
   return vec_perm((vector bool int)(0),
-                  vec_ld(a, b), 
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector float __ATTRS_o_ai
-vec_lvrx(int a, const float *b)
+vec_lvrx(int __a, const float *__b)
 {
   return vec_perm((vector float)(0),
-                  vec_ld(a, b),
-                  vec_lvsl(a, b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, __b));
 }
 
 static vector float __ATTRS_o_ai
-vec_lvrx(int a, const vector float *b)
+vec_lvrx(int __a, const vector float *__b)
 {
   return vec_perm((vector float)(0),
-                  vec_ld(a, b),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ld(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 /* vec_lvrxl */
 
 static vector signed char __ATTRS_o_ai
-vec_lvrxl(int a, const signed char *b)
+vec_lvrxl(int __a, const signed char *__b)
 {
   return vec_perm((vector signed char)(0),
-                  vec_ldl(a, b),
-                  vec_lvsl(a, b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, __b));
 }
 
 static vector signed char __ATTRS_o_ai
-vec_lvrxl(int a, const vector signed char *b)
+vec_lvrxl(int __a, const vector signed char *__b)
 {
   return vec_perm((vector signed char)(0),
-                  vec_ldl(a, b), 
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvrxl(int a, const unsigned char *b)
+vec_lvrxl(int __a, const unsigned char *__b)
 {
   return vec_perm((vector unsigned char)(0),
-                  vec_ldl(a, b),
-                  vec_lvsl(a, b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, __b));
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_lvrxl(int a, const vector unsigned char *b)
+vec_lvrxl(int __a, const vector unsigned char *__b)
 {
   return vec_perm((vector unsigned char)(0),
-                  vec_ldl(a, b), 
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector bool char __ATTRS_o_ai
-vec_lvrxl(int a, const vector bool char *b)
+vec_lvrxl(int __a, const vector bool char *__b)
 {
   return vec_perm((vector bool char)(0),
-                  vec_ldl(a, b), 
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector short __ATTRS_o_ai
-vec_lvrxl(int a, const short *b)
+vec_lvrxl(int __a, const short *__b)
 {
   return vec_perm((vector short)(0),
-                  vec_ldl(a, b),
-                  vec_lvsl(a, b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, __b));
 }
 
 static vector short __ATTRS_o_ai
-vec_lvrxl(int a, const vector short *b)
+vec_lvrxl(int __a, const vector short *__b)
 {
   return vec_perm((vector short)(0),
-                  vec_ldl(a, b),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_lvrxl(int a, const unsigned short *b)
+vec_lvrxl(int __a, const unsigned short *__b)
 {
   return vec_perm((vector unsigned short)(0),
-                  vec_ldl(a, b),
-                  vec_lvsl(a, b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, __b));
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_lvrxl(int a, const vector unsigned short *b)
+vec_lvrxl(int __a, const vector unsigned short *__b)
 {
   return vec_perm((vector unsigned short)(0),
-                  vec_ldl(a, b), 
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector bool short __ATTRS_o_ai
-vec_lvrxl(int a, const vector bool short *b)
+vec_lvrxl(int __a, const vector bool short *__b)
 {
   return vec_perm((vector bool short)(0),
-                  vec_ldl(a, b), 
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector pixel __ATTRS_o_ai
-vec_lvrxl(int a, const vector pixel *b)
+vec_lvrxl(int __a, const vector pixel *__b)
 {
   return vec_perm((vector pixel)(0),
-                  vec_ldl(a, b), 
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector int __ATTRS_o_ai
-vec_lvrxl(int a, const int *b)
+vec_lvrxl(int __a, const int *__b)
 {
   return vec_perm((vector int)(0),
-                  vec_ldl(a, b),
-                  vec_lvsl(a, b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, __b));
 }
 
 static vector int __ATTRS_o_ai
-vec_lvrxl(int a, const vector int *b)
+vec_lvrxl(int __a, const vector int *__b)
 {
   return vec_perm((vector int)(0),
-                  vec_ldl(a, b),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_lvrxl(int a, const unsigned int *b)
+vec_lvrxl(int __a, const unsigned int *__b)
 {
   return vec_perm((vector unsigned int)(0),
-                  vec_ldl(a, b),
-                  vec_lvsl(a, b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, __b));
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_lvrxl(int a, const vector unsigned int *b)
+vec_lvrxl(int __a, const vector unsigned int *__b)
 {
   return vec_perm((vector unsigned int)(0),
-                  vec_ldl(a, b), 
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector bool int __ATTRS_o_ai
-vec_lvrxl(int a, const vector bool int *b)
+vec_lvrxl(int __a, const vector bool int *__b)
 {
   return vec_perm((vector bool int)(0),
-                  vec_ldl(a, b), 
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 static vector float __ATTRS_o_ai
-vec_lvrxl(int a, const float *b)
+vec_lvrxl(int __a, const float *__b)
 {
   return vec_perm((vector float)(0),
-                  vec_ldl(a, b),
-                  vec_lvsl(a, b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, __b));
 }
 
 static vector float __ATTRS_o_ai
-vec_lvrxl(int a, const vector float *b)
+vec_lvrxl(int __a, const vector float *__b)
 {
   return vec_perm((vector float)(0),
-                  vec_ldl(a, b),
-                  vec_lvsl(a, (unsigned char *)b));
+                  vec_ldl(__a, __b),
+                  vec_lvsl(__a, (unsigned char *)__b));
 }
 
 /* vec_stvlx */
 
 static void __ATTRS_o_ai
-vec_stvlx(vector signed char a, int b, signed char *c)
+vec_stvlx(vector signed char __a, int __b, signed char *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, __c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlx(vector signed char a, int b, vector signed char *c)
+vec_stvlx(vector signed char __a, int __b, vector signed char *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlx(vector unsigned char a, int b, unsigned char *c)
+vec_stvlx(vector unsigned char __a, int __b, unsigned char *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, __c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlx(vector unsigned char a, int b, vector unsigned char *c)
+vec_stvlx(vector unsigned char __a, int __b, vector unsigned char *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlx(vector bool char a, int b, vector bool char *c)
+vec_stvlx(vector bool char __a, int __b, vector bool char *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlx(vector short a, int b, short *c)
+vec_stvlx(vector short __a, int __b, short *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, __c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlx(vector short a, int b, vector short *c)
+vec_stvlx(vector short __a, int __b, vector short *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlx(vector unsigned short a, int b, unsigned short *c)
+vec_stvlx(vector unsigned short __a, int __b, unsigned short *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, __c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlx(vector unsigned short a, int b, vector unsigned short *c)
+vec_stvlx(vector unsigned short __a, int __b, vector unsigned short *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlx(vector bool short a, int b, vector bool short *c)
+vec_stvlx(vector bool short __a, int __b, vector bool short *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlx(vector pixel a, int b, vector pixel *c)
+vec_stvlx(vector pixel __a, int __b, vector pixel *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlx(vector int a, int b, int *c)
+vec_stvlx(vector int __a, int __b, int *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, __c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlx(vector int a, int b, vector int *c)
+vec_stvlx(vector int __a, int __b, vector int *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlx(vector unsigned int a, int b, unsigned int *c)
+vec_stvlx(vector unsigned int __a, int __b, unsigned int *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, __c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlx(vector unsigned int a, int b, vector unsigned int *c)
+vec_stvlx(vector unsigned int __a, int __b, vector unsigned int *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlx(vector bool int a, int b, vector bool int *c)
+vec_stvlx(vector bool int __a, int __b, vector bool int *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlx(vector float a, int b, vector float *c)
+vec_stvlx(vector float __a, int __b, vector float *__c)
 {
-  return vec_st(vec_perm(vec_lvrx(b, c),
-                         a,
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(vec_lvrx(__b, __c),
+                         __a,
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 /* vec_stvlxl */
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector signed char a, int b, signed char *c)
+vec_stvlxl(vector signed char __a, int __b, signed char *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, __c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector signed char a, int b, vector signed char *c)
+vec_stvlxl(vector signed char __a, int __b, vector signed char *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector unsigned char a, int b, unsigned char *c)
+vec_stvlxl(vector unsigned char __a, int __b, unsigned char *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, __c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector unsigned char a, int b, vector unsigned char *c)
+vec_stvlxl(vector unsigned char __a, int __b, vector unsigned char *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector bool char a, int b, vector bool char *c)
+vec_stvlxl(vector bool char __a, int __b, vector bool char *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector short a, int b, short *c)
+vec_stvlxl(vector short __a, int __b, short *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, __c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector short a, int b, vector short *c)
+vec_stvlxl(vector short __a, int __b, vector short *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector unsigned short a, int b, unsigned short *c)
+vec_stvlxl(vector unsigned short __a, int __b, unsigned short *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, __c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector unsigned short a, int b, vector unsigned short *c)
+vec_stvlxl(vector unsigned short __a, int __b, vector unsigned short *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector bool short a, int b, vector bool short *c)
+vec_stvlxl(vector bool short __a, int __b, vector bool short *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector pixel a, int b, vector pixel *c)
+vec_stvlxl(vector pixel __a, int __b, vector pixel *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector int a, int b, int *c)
+vec_stvlxl(vector int __a, int __b, int *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, __c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector int a, int b, vector int *c)
+vec_stvlxl(vector int __a, int __b, vector int *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector unsigned int a, int b, unsigned int *c)
+vec_stvlxl(vector unsigned int __a, int __b, unsigned int *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, __c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector unsigned int a, int b, vector unsigned int *c)
+vec_stvlxl(vector unsigned int __a, int __b, vector unsigned int *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector bool int a, int b, vector bool int *c)
+vec_stvlxl(vector bool int __a, int __b, vector bool int *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvlxl(vector float a, int b, vector float *c)
+vec_stvlxl(vector float __a, int __b, vector float *__c)
 {
-  return vec_stl(vec_perm(vec_lvrx(b, c),
-                          a,
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(vec_lvrx(__b, __c),
+                          __a,
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 /* vec_stvrx */
 
 static void __ATTRS_o_ai
-vec_stvrx(vector signed char a, int b, signed char *c)
+vec_stvrx(vector signed char __a, int __b, signed char *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, __c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrx(vector signed char a, int b, vector signed char *c)
+vec_stvrx(vector signed char __a, int __b, vector signed char *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrx(vector unsigned char a, int b, unsigned char *c)
+vec_stvrx(vector unsigned char __a, int __b, unsigned char *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, __c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrx(vector unsigned char a, int b, vector unsigned char *c)
+vec_stvrx(vector unsigned char __a, int __b, vector unsigned char *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrx(vector bool char a, int b, vector bool char *c)
+vec_stvrx(vector bool char __a, int __b, vector bool char *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrx(vector short a, int b, short *c)
+vec_stvrx(vector short __a, int __b, short *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, __c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrx(vector short a, int b, vector short *c)
+vec_stvrx(vector short __a, int __b, vector short *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrx(vector unsigned short a, int b, unsigned short *c)
+vec_stvrx(vector unsigned short __a, int __b, unsigned short *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, __c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrx(vector unsigned short a, int b, vector unsigned short *c)
+vec_stvrx(vector unsigned short __a, int __b, vector unsigned short *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrx(vector bool short a, int b, vector bool short *c)
+vec_stvrx(vector bool short __a, int __b, vector bool short *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrx(vector pixel a, int b, vector pixel *c)
+vec_stvrx(vector pixel __a, int __b, vector pixel *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrx(vector int a, int b, int *c)
+vec_stvrx(vector int __a, int __b, int *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, __c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrx(vector int a, int b, vector int *c)
+vec_stvrx(vector int __a, int __b, vector int *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrx(vector unsigned int a, int b, unsigned int *c)
+vec_stvrx(vector unsigned int __a, int __b, unsigned int *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, __c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrx(vector unsigned int a, int b, vector unsigned int *c)
+vec_stvrx(vector unsigned int __a, int __b, vector unsigned int *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrx(vector bool int a, int b, vector bool int *c)
+vec_stvrx(vector bool int __a, int __b, vector bool int *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrx(vector float a, int b, vector float *c)
+vec_stvrx(vector float __a, int __b, vector float *__c)
 {
-  return vec_st(vec_perm(a,
-                         vec_lvlx(b, c),
-                         vec_lvsr(b, (unsigned char *)c)),
-                b, c);
+  return vec_st(vec_perm(__a,
+                         vec_lvlx(__b, __c),
+                         vec_lvsr(__b, (unsigned char *)__c)),
+                __b, __c);
 }
 
 /* vec_stvrxl */
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector signed char a, int b, signed char *c)
+vec_stvrxl(vector signed char __a, int __b, signed char *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, __c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector signed char a, int b, vector signed char *c)
+vec_stvrxl(vector signed char __a, int __b, vector signed char *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector unsigned char a, int b, unsigned char *c)
+vec_stvrxl(vector unsigned char __a, int __b, unsigned char *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, __c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector unsigned char a, int b, vector unsigned char *c)
+vec_stvrxl(vector unsigned char __a, int __b, vector unsigned char *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector bool char a, int b, vector bool char *c)
+vec_stvrxl(vector bool char __a, int __b, vector bool char *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector short a, int b, short *c)
+vec_stvrxl(vector short __a, int __b, short *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, __c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector short a, int b, vector short *c)
+vec_stvrxl(vector short __a, int __b, vector short *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector unsigned short a, int b, unsigned short *c)
+vec_stvrxl(vector unsigned short __a, int __b, unsigned short *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, __c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector unsigned short a, int b, vector unsigned short *c)
+vec_stvrxl(vector unsigned short __a, int __b, vector unsigned short *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector bool short a, int b, vector bool short *c)
+vec_stvrxl(vector bool short __a, int __b, vector bool short *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector pixel a, int b, vector pixel *c)
+vec_stvrxl(vector pixel __a, int __b, vector pixel *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector int a, int b, int *c)
+vec_stvrxl(vector int __a, int __b, int *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, __c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector int a, int b, vector int *c)
+vec_stvrxl(vector int __a, int __b, vector int *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector unsigned int a, int b, unsigned int *c)
+vec_stvrxl(vector unsigned int __a, int __b, unsigned int *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, __c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector unsigned int a, int b, vector unsigned int *c)
+vec_stvrxl(vector unsigned int __a, int __b, vector unsigned int *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector bool int a, int b, vector bool int *c)
+vec_stvrxl(vector bool int __a, int __b, vector bool int *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 static void __ATTRS_o_ai
-vec_stvrxl(vector float a, int b, vector float *c)
+vec_stvrxl(vector float __a, int __b, vector float *__c)
 {
-  return vec_stl(vec_perm(a,
-                          vec_lvlx(b, c),
-                          vec_lvsr(b, (unsigned char *)c)),
-                 b, c);
+  return vec_stl(vec_perm(__a,
+                          vec_lvlx(__b, __c),
+                          vec_lvsr(__b, (unsigned char *)__c)),
+                 __b, __c);
 }
 
 /* vec_promote */
 
 static vector signed char __ATTRS_o_ai
-vec_promote(signed char a, int b)
+vec_promote(signed char __a, int __b)
 {
-  vector signed char res = (vector signed char)(0);
-  res[b] = a;
-  return res;
+  vector signed char __res = (vector signed char)(0);
+  __res[__b] = __a;
+  return __res;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_promote(unsigned char a, int b)
+vec_promote(unsigned char __a, int __b)
 {
-  vector unsigned char res = (vector unsigned char)(0);
-  res[b] = a;
-  return res;
+  vector unsigned char __res = (vector unsigned char)(0);
+  __res[__b] = __a;
+  return __res;
 }
 
 static vector short __ATTRS_o_ai
-vec_promote(short a, int b)
+vec_promote(short __a, int __b)
 {
-  vector short res = (vector short)(0);
-  res[b] = a;
-  return res;
+  vector short __res = (vector short)(0);
+  __res[__b] = __a;
+  return __res;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_promote(unsigned short a, int b)
+vec_promote(unsigned short __a, int __b)
 {
-  vector unsigned short res = (vector unsigned short)(0);
-  res[b] = a;
-  return res;
+  vector unsigned short __res = (vector unsigned short)(0);
+  __res[__b] = __a;
+  return __res;
 }
 
 static vector int __ATTRS_o_ai
-vec_promote(int a, int b)
+vec_promote(int __a, int __b)
 {
-  vector int res = (vector int)(0);
-  res[b] = a;
-  return res;
+  vector int __res = (vector int)(0);
+  __res[__b] = __a;
+  return __res;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_promote(unsigned int a, int b)
+vec_promote(unsigned int __a, int __b)
 {
-  vector unsigned int res = (vector unsigned int)(0);
-  res[b] = a;
-  return res;
+  vector unsigned int __res = (vector unsigned int)(0);
+  __res[__b] = __a;
+  return __res;
 }
 
 static vector float __ATTRS_o_ai
-vec_promote(float a, int b)
+vec_promote(float __a, int __b)
 {
-  vector float res = (vector float)(0);
-  res[b] = a;
-  return res;
+  vector float __res = (vector float)(0);
+  __res[__b] = __a;
+  return __res;
 }
 
 /* vec_splats */
 
 static vector signed char __ATTRS_o_ai
-vec_splats(signed char a)
+vec_splats(signed char __a)
 {
-  return (vector signed char)(a);
+  return (vector signed char)(__a);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_splats(unsigned char a)
+vec_splats(unsigned char __a)
 {
-  return (vector unsigned char)(a);
+  return (vector unsigned char)(__a);
 }
 
 static vector short __ATTRS_o_ai
-vec_splats(short a)
+vec_splats(short __a)
 {
-  return (vector short)(a);
+  return (vector short)(__a);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_splats(unsigned short a)
+vec_splats(unsigned short __a)
 {
-  return (vector unsigned short)(a);
+  return (vector unsigned short)(__a);
 }
 
 static vector int __ATTRS_o_ai
-vec_splats(int a)
+vec_splats(int __a)
 {
-  return (vector int)(a);
+  return (vector int)(__a);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_splats(unsigned int a)
+vec_splats(unsigned int __a)
 {
-  return (vector unsigned int)(a);
+  return (vector unsigned int)(__a);
 }
 
 static vector float __ATTRS_o_ai
-vec_splats(float a)
+vec_splats(float __a)
 {
-  return (vector float)(a);
+  return (vector float)(__a);
 }
 
 /* ----------------------------- predicates --------------------------------- */
@@ -9940,1915 +9940,1915 @@
 /* vec_all_eq */
 
 static int __ATTRS_o_ai
-vec_all_eq(vector signed char a, vector signed char b)
+vec_all_eq(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)a, (vector char)b);
+  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector signed char a, vector bool char b)
+vec_all_eq(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)a, (vector char)b);
+  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector unsigned char a, vector unsigned char b)
+vec_all_eq(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)a, (vector char)b);
+  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector unsigned char a, vector bool char b)
+vec_all_eq(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)a, (vector char)b);
+  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector bool char a, vector signed char b)
+vec_all_eq(vector bool char __a, vector signed char __b)
 {
-  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)a, (vector char)b);
+  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector bool char a, vector unsigned char b)
+vec_all_eq(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)a, (vector char)b);
+  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector bool char a, vector bool char b)
+vec_all_eq(vector bool char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)a, (vector char)b);
+  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector short a, vector short b)
+vec_all_eq(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vcmpequh_p(__CR6_LT, a, b);
+  return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector short a, vector bool short b)
+vec_all_eq(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vcmpequh_p(__CR6_LT, a, (vector short)b);
+  return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector unsigned short a, vector unsigned short b)
+vec_all_eq(vector unsigned short __a, vector unsigned short __b)
 {
   return
-    __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)a, (vector short)b);
+    __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector unsigned short a, vector bool short b)
+vec_all_eq(vector unsigned short __a, vector bool short __b)
 {
   return
-    __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)a, (vector short)b);
+    __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector bool short a, vector short b)
+vec_all_eq(vector bool short __a, vector short __b)
 {
   return
-    __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)a, (vector short)b);
+    __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector bool short a, vector unsigned short b)
+vec_all_eq(vector bool short __a, vector unsigned short __b)
 {
   return
-    __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)a, (vector short)b);
+    __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector bool short a, vector bool short b)
+vec_all_eq(vector bool short __a, vector bool short __b)
 {
   return
-    __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)a, (vector short)b);
+    __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector pixel a, vector pixel b)
+vec_all_eq(vector pixel __a, vector pixel __b)
 {
   return
-    __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)a, (vector short)b);
+    __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector int a, vector int b)
+vec_all_eq(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_LT, a, b);
+  return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector int a, vector bool int b)
+vec_all_eq(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_LT, a, (vector int)b);
+  return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector unsigned int a, vector unsigned int b)
+vec_all_eq(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)a, (vector int)b);
+  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector unsigned int a, vector bool int b)
+vec_all_eq(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)a, (vector int)b);
+  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector bool int a, vector int b)
+vec_all_eq(vector bool int __a, vector int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)a, (vector int)b);
+  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector bool int a, vector unsigned int b)
+vec_all_eq(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)a, (vector int)b);
+  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector bool int a, vector bool int b)
+vec_all_eq(vector bool int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)a, (vector int)b);
+  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_eq(vector float a, vector float b)
+vec_all_eq(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpeqfp_p(__CR6_LT, a, b);
+  return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __b);
 }
 
 /* vec_all_ge */
 
 static int __ATTRS_o_ai
-vec_all_ge(vector signed char a, vector signed char b)
+vec_all_ge(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, b, a);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector signed char a, vector bool char b)
+vec_all_ge(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, (vector signed char)b, a);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, (vector signed char)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector unsigned char a, vector unsigned char b)
+vec_all_ge(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, b, a);
+  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector unsigned char a, vector bool char b)
+vec_all_ge(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)b, a);
+  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector bool char a, vector signed char b)
+vec_all_ge(vector bool char __a, vector signed char __b)
 {
   return __builtin_altivec_vcmpgtub_p(__CR6_EQ,
-                                      (vector unsigned char)b,
-                                      (vector unsigned char)a);
+                                      (vector unsigned char)__b,
+                                      (vector unsigned char)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector bool char a, vector unsigned char b)
+vec_all_ge(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, b, (vector unsigned char)a);
+  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, (vector unsigned char)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector bool char a, vector bool char b)
+vec_all_ge(vector bool char __a, vector bool char __b)
 {
   return __builtin_altivec_vcmpgtub_p(__CR6_EQ,
-                                      (vector unsigned char)b,
-                                      (vector unsigned char)a);
+                                      (vector unsigned char)__b,
+                                      (vector unsigned char)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector short a, vector short b)
+vec_all_ge(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, b, a);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector short a, vector bool short b)
+vec_all_ge(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, (vector short)b, a);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, (vector short)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector unsigned short a, vector unsigned short b)
+vec_all_ge(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, b, a);
+  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector unsigned short a, vector bool short b)
+vec_all_ge(vector unsigned short __a, vector bool short __b)
 {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)b, a);
+  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector bool short a, vector short b)
+vec_all_ge(vector bool short __a, vector short __b)
 {
   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ,
-                                      (vector unsigned short)b,
-                                      (vector unsigned short)a);
+                                      (vector unsigned short)__b,
+                                      (vector unsigned short)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector bool short a, vector unsigned short b)
+vec_all_ge(vector bool short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, b, (vector unsigned short)a);
+  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b, (vector unsigned short)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector bool short a, vector bool short b)
+vec_all_ge(vector bool short __a, vector bool short __b)
 {
   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ,
-                                      (vector unsigned short)b,
-                                      (vector unsigned short)a);
+                                      (vector unsigned short)__b,
+                                      (vector unsigned short)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector int a, vector int b)
+vec_all_ge(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, b, a);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector int a, vector bool int b)
+vec_all_ge(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, (vector int)b, a);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, (vector int)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector unsigned int a, vector unsigned int b)
+vec_all_ge(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, b, a);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector unsigned int a, vector bool int b)
+vec_all_ge(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)b, a);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector bool int a, vector int b)
+vec_all_ge(vector bool int __a, vector int __b)
 {
   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ,
-                                      (vector unsigned int)b,
-                                      (vector unsigned int)a);
+                                      (vector unsigned int)__b,
+                                      (vector unsigned int)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector bool int a, vector unsigned int b)
+vec_all_ge(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, b, (vector unsigned int)a);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, (vector unsigned int)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector bool int a, vector bool int b)
+vec_all_ge(vector bool int __a, vector bool int __b)
 {
   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ,
-                                      (vector unsigned int)b,
-                                      (vector unsigned int)a);
+                                      (vector unsigned int)__b,
+                                      (vector unsigned int)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_ge(vector float a, vector float b)
+vec_all_ge(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpgefp_p(__CR6_LT, a, b);
+  return __builtin_altivec_vcmpgefp_p(__CR6_LT, __a, __b);
 }
 
 /* vec_all_gt */
 
 static int __ATTRS_o_ai
-vec_all_gt(vector signed char a, vector signed char b)
+vec_all_gt(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, a, b);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector signed char a, vector bool char b)
+vec_all_gt(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, a, (vector signed char)b);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, (vector signed char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector unsigned char a, vector unsigned char b)
+vec_all_gt(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_LT, a, b);
+  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector unsigned char a, vector bool char b)
+vec_all_gt(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_LT, a, (vector unsigned char)b);
+  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, (vector unsigned char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector bool char a, vector signed char b)
+vec_all_gt(vector bool char __a, vector signed char __b)
 {
   return __builtin_altivec_vcmpgtub_p(__CR6_LT,
-                                      (vector unsigned char)a,
-                                      (vector unsigned char)b);
+                                      (vector unsigned char)__a,
+                                      (vector unsigned char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector bool char a, vector unsigned char b)
+vec_all_gt(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)a, b);
+  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector bool char a, vector bool char b)
+vec_all_gt(vector bool char __a, vector bool char __b)
 {
   return __builtin_altivec_vcmpgtub_p(__CR6_LT,
-                                      (vector unsigned char)a,
-                                      (vector unsigned char)b);
+                                      (vector unsigned char)__a,
+                                      (vector unsigned char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector short a, vector short b)
+vec_all_gt(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, a, b);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector short a, vector bool short b)
+vec_all_gt(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, a, (vector short)b);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector unsigned short a, vector unsigned short b)
+vec_all_gt(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, a, b);
+  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector unsigned short a, vector bool short b)
+vec_all_gt(vector unsigned short __a, vector bool short __b)
 {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, a, (vector unsigned short)b);
+  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a, (vector unsigned short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector bool short a, vector short b)
+vec_all_gt(vector bool short __a, vector short __b)
 {
   return __builtin_altivec_vcmpgtuh_p(__CR6_LT,
-                                      (vector unsigned short)a,
-                                      (vector unsigned short)b);
+                                      (vector unsigned short)__a,
+                                      (vector unsigned short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector bool short a, vector unsigned short b)
+vec_all_gt(vector bool short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)a, b);
+  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector bool short a, vector bool short b)
+vec_all_gt(vector bool short __a, vector bool short __b)
 {
   return __builtin_altivec_vcmpgtuh_p(__CR6_LT,
-                                      (vector unsigned short)a,
-                                      (vector unsigned short)b);
+                                      (vector unsigned short)__a,
+                                      (vector unsigned short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector int a, vector int b)
+vec_all_gt(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, a, b);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector int a, vector bool int b)
+vec_all_gt(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, a, (vector int)b);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector unsigned int a, vector unsigned int b)
+vec_all_gt(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, a, b);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector unsigned int a, vector bool int b)
+vec_all_gt(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, a, (vector unsigned int)b);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, (vector unsigned int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector bool int a, vector int b)
+vec_all_gt(vector bool int __a, vector int __b)
 {
   return __builtin_altivec_vcmpgtuw_p(__CR6_LT,
-                                      (vector unsigned int)a,
-                                      (vector unsigned int)b);
+                                      (vector unsigned int)__a,
+                                      (vector unsigned int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector bool int a, vector unsigned int b)
+vec_all_gt(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)a, b);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector bool int a, vector bool int b)
+vec_all_gt(vector bool int __a, vector bool int __b)
 {
   return __builtin_altivec_vcmpgtuw_p(__CR6_LT,
-                                      (vector unsigned int)a,
-                                      (vector unsigned int)b);
+                                      (vector unsigned int)__a,
+                                      (vector unsigned int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_gt(vector float a, vector float b)
+vec_all_gt(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpgtfp_p(__CR6_LT, a, b);
+  return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __a, __b);
 }
 
 /* vec_all_in */
 
 static int __attribute__((__always_inline__))
-vec_all_in(vector float a, vector float b)
+vec_all_in(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpbfp_p(__CR6_EQ, a, b);
+  return __builtin_altivec_vcmpbfp_p(__CR6_EQ, __a, __b);
 }
 
 /* vec_all_le */
 
 static int __ATTRS_o_ai
-vec_all_le(vector signed char a, vector signed char b)
+vec_all_le(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, a, b);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector signed char a, vector bool char b)
+vec_all_le(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, a, (vector signed char)b);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, (vector signed char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector unsigned char a, vector unsigned char b)
+vec_all_le(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, a, b);
+  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector unsigned char a, vector bool char b)
+vec_all_le(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, a, (vector unsigned char)b);
+  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, (vector unsigned char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector bool char a, vector signed char b)
+vec_all_le(vector bool char __a, vector signed char __b)
 {
   return __builtin_altivec_vcmpgtub_p(__CR6_EQ,
-                                      (vector unsigned char)a,
-                                      (vector unsigned char)b);
+                                      (vector unsigned char)__a,
+                                      (vector unsigned char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector bool char a, vector unsigned char b)
+vec_all_le(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)a, b);
+  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector bool char a, vector bool char b)
+vec_all_le(vector bool char __a, vector bool char __b)
 {
   return __builtin_altivec_vcmpgtub_p(__CR6_EQ,
-                                      (vector unsigned char)a,
-                                      (vector unsigned char)b);
+                                      (vector unsigned char)__a,
+                                      (vector unsigned char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector short a, vector short b)
+vec_all_le(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, a, b);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector short a, vector bool short b)
+vec_all_le(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, a, (vector short)b);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector unsigned short a, vector unsigned short b)
+vec_all_le(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, a, b);
+  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector unsigned short a, vector bool short b)
+vec_all_le(vector unsigned short __a, vector bool short __b)
 {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, a, (vector unsigned short)b);
+  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a, (vector unsigned short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector bool short a, vector short b)
+vec_all_le(vector bool short __a, vector short __b)
 {
   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ,
-                                      (vector unsigned short)a,
-                                      (vector unsigned short)b);
+                                      (vector unsigned short)__a,
+                                      (vector unsigned short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector bool short a, vector unsigned short b)
+vec_all_le(vector bool short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)a, b);
+  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector bool short a, vector bool short b)
+vec_all_le(vector bool short __a, vector bool short __b)
 {
   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ,
-                                      (vector unsigned short)a,
-                                      (vector unsigned short)b);
+                                      (vector unsigned short)__a,
+                                      (vector unsigned short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector int a, vector int b)
+vec_all_le(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, a, b);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector int a, vector bool int b)
+vec_all_le(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, a, (vector int)b);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector unsigned int a, vector unsigned int b)
+vec_all_le(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, a, b);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector unsigned int a, vector bool int b)
+vec_all_le(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, a, (vector unsigned int)b);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, (vector unsigned int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector bool int a, vector int b)
+vec_all_le(vector bool int __a, vector int __b)
 {
   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ,
-                                      (vector unsigned int)a,
-                                      (vector unsigned int)b);
+                                      (vector unsigned int)__a,
+                                      (vector unsigned int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector bool int a, vector unsigned int b)
+vec_all_le(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)a, b);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector bool int a, vector bool int b)
+vec_all_le(vector bool int __a, vector bool int __b)
 {
   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ,
-                                      (vector unsigned int)a,
-                                      (vector unsigned int)b);
+                                      (vector unsigned int)__a,
+                                      (vector unsigned int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_le(vector float a, vector float b)
+vec_all_le(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpgefp_p(__CR6_LT, b, a);
+  return __builtin_altivec_vcmpgefp_p(__CR6_LT, __b, __a);
 }
 
 /* vec_all_lt */
 
 static int __ATTRS_o_ai
-vec_all_lt(vector signed char a, vector signed char b)
+vec_all_lt(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, b, a);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector signed char a, vector bool char b)
+vec_all_lt(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, (vector signed char)b, a);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, (vector signed char)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector unsigned char a, vector unsigned char b)
+vec_all_lt(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_LT, b, a);
+  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector unsigned char a, vector bool char b)
+vec_all_lt(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)b, a);
+  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector bool char a, vector signed char b)
+vec_all_lt(vector bool char __a, vector signed char __b)
 {
   return __builtin_altivec_vcmpgtub_p(__CR6_LT,
-                                      (vector unsigned char)b,
-                                      (vector unsigned char)a);
+                                      (vector unsigned char)__b,
+                                      (vector unsigned char)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector bool char a, vector unsigned char b)
+vec_all_lt(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_LT, b, (vector unsigned char)a);
+  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, (vector unsigned char)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector bool char a, vector bool char b)
+vec_all_lt(vector bool char __a, vector bool char __b)
 {
   return __builtin_altivec_vcmpgtub_p(__CR6_LT,
-                                      (vector unsigned char)b,
-                                      (vector unsigned char)a);
+                                      (vector unsigned char)__b,
+                                      (vector unsigned char)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector short a, vector short b)
+vec_all_lt(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, b, a);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector short a, vector bool short b)
+vec_all_lt(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, (vector short)b, a);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, (vector short)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector unsigned short a, vector unsigned short b)
+vec_all_lt(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, b, a);
+  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector unsigned short a, vector bool short b)
+vec_all_lt(vector unsigned short __a, vector bool short __b)
 {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)b, a);
+  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector bool short a, vector short b)
+vec_all_lt(vector bool short __a, vector short __b)
 {
   return __builtin_altivec_vcmpgtuh_p(__CR6_LT,
-                                      (vector unsigned short)b,
-                                      (vector unsigned short)a);
+                                      (vector unsigned short)__b,
+                                      (vector unsigned short)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector bool short a, vector unsigned short b)
+vec_all_lt(vector bool short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, b, (vector unsigned short)a);
+  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b, (vector unsigned short)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector bool short a, vector bool short b)
+vec_all_lt(vector bool short __a, vector bool short __b)
 {
   return __builtin_altivec_vcmpgtuh_p(__CR6_LT,
-                                      (vector unsigned short)b,
-                                      (vector unsigned short)a);
+                                      (vector unsigned short)__b,
+                                      (vector unsigned short)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector int a, vector int b)
+vec_all_lt(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, b, a);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector int a, vector bool int b)
+vec_all_lt(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, (vector int)b, a);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, (vector int)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector unsigned int a, vector unsigned int b)
+vec_all_lt(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, b, a);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector unsigned int a, vector bool int b)
+vec_all_lt(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)b, a);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector bool int a, vector int b)
+vec_all_lt(vector bool int __a, vector int __b)
 {
   return __builtin_altivec_vcmpgtuw_p(__CR6_LT,
-                                      (vector unsigned int)b,
-                                      (vector unsigned int)a);
+                                      (vector unsigned int)__b,
+                                      (vector unsigned int)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector bool int a, vector unsigned int b)
+vec_all_lt(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, b, (vector unsigned int)a);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, (vector unsigned int)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector bool int a, vector bool int b)
+vec_all_lt(vector bool int __a, vector bool int __b)
 {
   return __builtin_altivec_vcmpgtuw_p(__CR6_LT,
-                                      (vector unsigned int)b,
-                                      (vector unsigned int)a);
+                                      (vector unsigned int)__b,
+                                      (vector unsigned int)__a);
 }
 
 static int __ATTRS_o_ai
-vec_all_lt(vector float a, vector float b)
+vec_all_lt(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpgtfp_p(__CR6_LT, b, a);
+  return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __b, __a);
 }
 
 /* vec_all_nan */
 
 static int __attribute__((__always_inline__))
-vec_all_nan(vector float a)
+vec_all_nan(vector float __a)
 {
-  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, a, a);
+  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __a);
 }
 
 /* vec_all_ne */
 
 static int __ATTRS_o_ai
-vec_all_ne(vector signed char a, vector signed char b)
+vec_all_ne(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)a, (vector char)b);
+  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector signed char a, vector bool char b)
+vec_all_ne(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)a, (vector char)b);
+  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector unsigned char a, vector unsigned char b)
+vec_all_ne(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)a, (vector char)b);
+  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector unsigned char a, vector bool char b)
+vec_all_ne(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)a, (vector char)b);
+  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector bool char a, vector signed char b)
+vec_all_ne(vector bool char __a, vector signed char __b)
 {
-  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)a, (vector char)b);
+  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector bool char a, vector unsigned char b)
+vec_all_ne(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)a, (vector char)b);
+  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector bool char a, vector bool char b)
+vec_all_ne(vector bool char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)a, (vector char)b);
+  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector short a, vector short b)
+vec_all_ne(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vcmpequh_p(__CR6_EQ, a, b);
+  return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector short a, vector bool short b)
+vec_all_ne(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vcmpequh_p(__CR6_EQ, a, (vector short)b);
+  return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector unsigned short a, vector unsigned short b)
+vec_all_ne(vector unsigned short __a, vector unsigned short __b)
 {
   return
-    __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)a, (vector short)b);
+    __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector unsigned short a, vector bool short b)
+vec_all_ne(vector unsigned short __a, vector bool short __b)
 {
   return
-    __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)a, (vector short)b);
+    __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector bool short a, vector short b)
+vec_all_ne(vector bool short __a, vector short __b)
 {
   return
-    __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)a, (vector short)b);
+    __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector bool short a, vector unsigned short b)
+vec_all_ne(vector bool short __a, vector unsigned short __b)
 {
   return
-    __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)a, (vector short)b);
+    __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector bool short a, vector bool short b)
+vec_all_ne(vector bool short __a, vector bool short __b)
 {
   return
-    __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)a, (vector short)b);
+    __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector pixel a, vector pixel b)
+vec_all_ne(vector pixel __a, vector pixel __b)
 {
   return
-    __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)a, (vector short)b);
+    __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector int a, vector int b)
+vec_all_ne(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_EQ, a, b);
+  return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector int a, vector bool int b)
+vec_all_ne(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_EQ, a, (vector int)b);
+  return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector unsigned int a, vector unsigned int b)
+vec_all_ne(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)a, (vector int)b);
+  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector unsigned int a, vector bool int b)
+vec_all_ne(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)a, (vector int)b);
+  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector bool int a, vector int b)
+vec_all_ne(vector bool int __a, vector int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)a, (vector int)b);
+  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector bool int a, vector unsigned int b)
+vec_all_ne(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)a, (vector int)b);
+  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector bool int a, vector bool int b)
+vec_all_ne(vector bool int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)a, (vector int)b);
+  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_all_ne(vector float a, vector float b)
+vec_all_ne(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, a, b);
+  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __b);
 }
 
 /* vec_all_nge */
 
 static int __attribute__((__always_inline__))
-vec_all_nge(vector float a, vector float b)
+vec_all_nge(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpgefp_p(__CR6_EQ, a, b);
+  return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __a, __b);
 }
 
 /* vec_all_ngt */
 
 static int __attribute__((__always_inline__))
-vec_all_ngt(vector float a, vector float b)
+vec_all_ngt(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, a, b);
+  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __a, __b);
 }
 
 /* vec_all_nle */
 
 static int __attribute__((__always_inline__))
-vec_all_nle(vector float a, vector float b)
+vec_all_nle(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpgefp_p(__CR6_EQ, b, a);
+  return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __b, __a);
 }
 
 /* vec_all_nlt */
 
 static int __attribute__((__always_inline__))
-vec_all_nlt(vector float a, vector float b)
+vec_all_nlt(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, b, a);
+  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __b, __a);
 }
 
 /* vec_all_numeric */
 
 static int __attribute__((__always_inline__))
-vec_all_numeric(vector float a)
+vec_all_numeric(vector float __a)
 {
-  return __builtin_altivec_vcmpeqfp_p(__CR6_LT, a, a);
+  return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __a);
 }
 
 /* vec_any_eq */
 
 static int __ATTRS_o_ai
-vec_any_eq(vector signed char a, vector signed char b)
+vec_any_eq(vector signed char __a, vector signed char __b)
 {
   return
-    __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)a, (vector char)b);
+    __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector signed char a, vector bool char b)
+vec_any_eq(vector signed char __a, vector bool char __b)
 {
   return
-    __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)a, (vector char)b);
+    __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector unsigned char a, vector unsigned char b)
+vec_any_eq(vector unsigned char __a, vector unsigned char __b)
 {
   return
-    __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)a, (vector char)b);
+    __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector unsigned char a, vector bool char b)
+vec_any_eq(vector unsigned char __a, vector bool char __b)
 {
   return
-    __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)a, (vector char)b);
+    __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector bool char a, vector signed char b)
+vec_any_eq(vector bool char __a, vector signed char __b)
 {
   return
-    __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)a, (vector char)b);
+    __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector bool char a, vector unsigned char b)
+vec_any_eq(vector bool char __a, vector unsigned char __b)
 {
   return
-    __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)a, (vector char)b);
+    __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector bool char a, vector bool char b)
+vec_any_eq(vector bool char __a, vector bool char __b)
 {
   return
-    __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)a, (vector char)b);
+    __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector short a, vector short b)
+vec_any_eq(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, a, b);
+  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector short a, vector bool short b)
+vec_any_eq(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, a, (vector short)b);
+  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector unsigned short a, vector unsigned short b)
+vec_any_eq(vector unsigned short __a, vector unsigned short __b)
 {
   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, 
-                                      (vector short)a,
-                                      (vector short)b);
+                                      (vector short)__a,
+                                      (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector unsigned short a, vector bool short b)
+vec_any_eq(vector unsigned short __a, vector bool short __b)
 {
   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, 
-                                      (vector short)a,
-                                      (vector short)b);
+                                      (vector short)__a,
+                                      (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector bool short a, vector short b)
+vec_any_eq(vector bool short __a, vector short __b)
 {
   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV,
-                                      (vector short)a,
-                                      (vector short)b);
+                                      (vector short)__a,
+                                      (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector bool short a, vector unsigned short b)
+vec_any_eq(vector bool short __a, vector unsigned short __b)
 {
   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV,
-                                      (vector short)a,
-                                      (vector short)b);
+                                      (vector short)__a,
+                                      (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector bool short a, vector bool short b)
+vec_any_eq(vector bool short __a, vector bool short __b)
 {
   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV,
-                                      (vector short)a,
-                                      (vector short)b);
+                                      (vector short)__a,
+                                      (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector pixel a, vector pixel b)
+vec_any_eq(vector pixel __a, vector pixel __b)
 {
   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, 
-                                      (vector short)a,
-                                      (vector short)b);
+                                      (vector short)__a,
+                                      (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector int a, vector int b)
+vec_any_eq(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, a, b);
+  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector int a, vector bool int b)
+vec_any_eq(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, a, (vector int)b);
+  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector unsigned int a, vector unsigned int b)
+vec_any_eq(vector unsigned int __a, vector unsigned int __b)
 {
   return
-    __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)a, (vector int)b);
+    __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector unsigned int a, vector bool int b)
+vec_any_eq(vector unsigned int __a, vector bool int __b)
 {
   return
-    __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)a, (vector int)b);
+    __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector bool int a, vector int b)
+vec_any_eq(vector bool int __a, vector int __b)
 {
   return
-    __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)a, (vector int)b);
+    __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector bool int a, vector unsigned int b)
+vec_any_eq(vector bool int __a, vector unsigned int __b)
 {
   return
-    __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)a, (vector int)b);
+    __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector bool int a, vector bool int b)
+vec_any_eq(vector bool int __a, vector bool int __b)
 {
   return
-    __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)a, (vector int)b);
+    __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_eq(vector float a, vector float b)
+vec_any_eq(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, a, b);
+  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __b);
 }
 
 /* vec_any_ge */
 
 static int __ATTRS_o_ai
-vec_any_ge(vector signed char a, vector signed char b)
+vec_any_ge(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, b, a);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector signed char a, vector bool char b)
+vec_any_ge(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, (vector signed char)b, a);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, (vector signed char)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector unsigned char a, vector unsigned char b)
+vec_any_ge(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, b, a);
+  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector unsigned char a, vector bool char b)
+vec_any_ge(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)b, a);
+  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector bool char a, vector signed char b)
+vec_any_ge(vector bool char __a, vector signed char __b)
 {
   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV,
-                                      (vector unsigned char)b,
-                                      (vector unsigned char)a);
+                                      (vector unsigned char)__b,
+                                      (vector unsigned char)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector bool char a, vector unsigned char b)
+vec_any_ge(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, b, (vector unsigned char)a);
+  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b, (vector unsigned char)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector bool char a, vector bool char b)
+vec_any_ge(vector bool char __a, vector bool char __b)
 {
   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV,
-                                      (vector unsigned char)b,
-                                      (vector unsigned char)a);
+                                      (vector unsigned char)__b,
+                                      (vector unsigned char)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector short a, vector short b)
+vec_any_ge(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, b, a);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector short a, vector bool short b)
+vec_any_ge(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, (vector short)b, a);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, (vector short)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector unsigned short a, vector unsigned short b)
+vec_any_ge(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, b, a);
+  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector unsigned short a, vector bool short b)
+vec_any_ge(vector unsigned short __a, vector bool short __b)
 {
   return
-    __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)b, a);
+    __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector bool short a, vector short b)
+vec_any_ge(vector bool short __a, vector short __b)
 {
   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV,
-                                      (vector unsigned short)b,
-                                      (vector unsigned short)a);
+                                      (vector unsigned short)__b,
+                                      (vector unsigned short)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector bool short a, vector unsigned short b)
+vec_any_ge(vector bool short __a, vector unsigned short __b)
 {
   return 
-    __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, b, (vector unsigned short)a);
+    __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b, (vector unsigned short)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector bool short a, vector bool short b)
+vec_any_ge(vector bool short __a, vector bool short __b)
 {
   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV,
-                                      (vector unsigned short)b,
-                                      (vector unsigned short)a);
+                                      (vector unsigned short)__b,
+                                      (vector unsigned short)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector int a, vector int b)
+vec_any_ge(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, b, a);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector int a, vector bool int b)
+vec_any_ge(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, (vector int)b, a);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, (vector int)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector unsigned int a, vector unsigned int b)
+vec_any_ge(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, b, a);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector unsigned int a, vector bool int b)
+vec_any_ge(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)b, a);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector bool int a, vector int b)
+vec_any_ge(vector bool int __a, vector int __b)
 {
   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV,
-                                      (vector unsigned int)b,
-                                      (vector unsigned int)a);
+                                      (vector unsigned int)__b,
+                                      (vector unsigned int)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector bool int a, vector unsigned int b)
+vec_any_ge(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, b, (vector unsigned int)a);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b, (vector unsigned int)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector bool int a, vector bool int b)
+vec_any_ge(vector bool int __a, vector bool int __b)
 {
   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV,
-                                      (vector unsigned int)b,
-                                      (vector unsigned int)a);
+                                      (vector unsigned int)__b,
+                                      (vector unsigned int)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_ge(vector float a, vector float b)
+vec_any_ge(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, a, b);
+  return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __a, __b);
 }
 
 /* vec_any_gt */
 
 static int __ATTRS_o_ai
-vec_any_gt(vector signed char a, vector signed char b)
+vec_any_gt(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, a, b);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector signed char a, vector bool char b)
+vec_any_gt(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, a, (vector signed char)b);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a, (vector signed char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector unsigned char a, vector unsigned char b)
+vec_any_gt(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, a, b);
+  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector unsigned char a, vector bool char b)
+vec_any_gt(vector unsigned char __a, vector bool char __b)
 {
   return 
-    __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, a, (vector unsigned char)b);
+    __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a, (vector unsigned char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector bool char a, vector signed char b)
+vec_any_gt(vector bool char __a, vector signed char __b)
 {
   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV,
-                                      (vector unsigned char)a,
-                                      (vector unsigned char)b);
+                                      (vector unsigned char)__a,
+                                      (vector unsigned char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector bool char a, vector unsigned char b)
+vec_any_gt(vector bool char __a, vector unsigned char __b)
 {
   return 
-    __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)a, b);
+    __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector bool char a, vector bool char b)
+vec_any_gt(vector bool char __a, vector bool char __b)
 {
   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV,
-                                      (vector unsigned char)a,
-                                      (vector unsigned char)b);
+                                      (vector unsigned char)__a,
+                                      (vector unsigned char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector short a, vector short b)
+vec_any_gt(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, a, b);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector short a, vector bool short b)
+vec_any_gt(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, a, (vector short)b);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector unsigned short a, vector unsigned short b)
+vec_any_gt(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, a, b);
+  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector unsigned short a, vector bool short b)
+vec_any_gt(vector unsigned short __a, vector bool short __b)
 {
   return 
-    __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, a, (vector unsigned short)b);
+    __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a, (vector unsigned short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector bool short a, vector short b)
+vec_any_gt(vector bool short __a, vector short __b)
 {
   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV,
-                                      (vector unsigned short)a,
-                                      (vector unsigned short)b);
+                                      (vector unsigned short)__a,
+                                      (vector unsigned short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector bool short a, vector unsigned short b)
+vec_any_gt(vector bool short __a, vector unsigned short __b)
 {
   return
-    __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)a, b);
+    __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector bool short a, vector bool short b)
+vec_any_gt(vector bool short __a, vector bool short __b)
 {
   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV,
-                                      (vector unsigned short)a,
-                                      (vector unsigned short)b);
+                                      (vector unsigned short)__a,
+                                      (vector unsigned short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector int a, vector int b)
+vec_any_gt(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, a, b);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector int a, vector bool int b)
+vec_any_gt(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, a, (vector int)b);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector unsigned int a, vector unsigned int b)
+vec_any_gt(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, a, b);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector unsigned int a, vector bool int b)
+vec_any_gt(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, a, (vector unsigned int)b);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a, (vector unsigned int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector bool int a, vector int b)
+vec_any_gt(vector bool int __a, vector int __b)
 {
   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV,
-                                      (vector unsigned int)a,
-                                      (vector unsigned int)b);
+                                      (vector unsigned int)__a,
+                                      (vector unsigned int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector bool int a, vector unsigned int b)
+vec_any_gt(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)a, b);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector bool int a, vector bool int b)
+vec_any_gt(vector bool int __a, vector bool int __b)
 {
   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV,
-                                      (vector unsigned int)a,
-                                      (vector unsigned int)b);
+                                      (vector unsigned int)__a,
+                                      (vector unsigned int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_gt(vector float a, vector float b)
+vec_any_gt(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, a, b);
+  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __a, __b);
 }
 
 /* vec_any_le */
 
 static int __ATTRS_o_ai
-vec_any_le(vector signed char a, vector signed char b)
+vec_any_le(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, a, b);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector signed char a, vector bool char b)
+vec_any_le(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, a, (vector signed char)b);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a, (vector signed char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector unsigned char a, vector unsigned char b)
+vec_any_le(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, a, b);
+  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector unsigned char a, vector bool char b)
+vec_any_le(vector unsigned char __a, vector bool char __b)
 {
   return 
-    __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, a, (vector unsigned char)b);
+    __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a, (vector unsigned char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector bool char a, vector signed char b)
+vec_any_le(vector bool char __a, vector signed char __b)
 {
   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV,
-                                      (vector unsigned char)a,
-                                      (vector unsigned char)b);
+                                      (vector unsigned char)__a,
+                                      (vector unsigned char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector bool char a, vector unsigned char b)
+vec_any_le(vector bool char __a, vector unsigned char __b)
 {
   return 
-    __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)a, b);
+    __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector bool char a, vector bool char b)
+vec_any_le(vector bool char __a, vector bool char __b)
 {
   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV,
-                                      (vector unsigned char)a,
-                                      (vector unsigned char)b);
+                                      (vector unsigned char)__a,
+                                      (vector unsigned char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector short a, vector short b)
+vec_any_le(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, a, b);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector short a, vector bool short b)
+vec_any_le(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, a, (vector short)b);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector unsigned short a, vector unsigned short b)
+vec_any_le(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, a, b);
+  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector unsigned short a, vector bool short b)
+vec_any_le(vector unsigned short __a, vector bool short __b)
 {
   return 
-    __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, a, (vector unsigned short)b);
+    __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a, (vector unsigned short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector bool short a, vector short b)
+vec_any_le(vector bool short __a, vector short __b)
 {
   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV,
-                                      (vector unsigned short)a,
-                                      (vector unsigned short)b);
+                                      (vector unsigned short)__a,
+                                      (vector unsigned short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector bool short a, vector unsigned short b)
+vec_any_le(vector bool short __a, vector unsigned short __b)
 {
   return 
-    __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)a, b);
+    __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector bool short a, vector bool short b)
+vec_any_le(vector bool short __a, vector bool short __b)
 {
   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV,
-                                      (vector unsigned short)a,
-                                      (vector unsigned short)b);
+                                      (vector unsigned short)__a,
+                                      (vector unsigned short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector int a, vector int b)
+vec_any_le(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, a, b);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector int a, vector bool int b)
+vec_any_le(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, a, (vector int)b);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector unsigned int a, vector unsigned int b)
+vec_any_le(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, a, b);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector unsigned int a, vector bool int b)
+vec_any_le(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, a, (vector unsigned int)b);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a, (vector unsigned int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector bool int a, vector int b)
+vec_any_le(vector bool int __a, vector int __b)
 {
   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV,
-                                      (vector unsigned int)a,
-                                      (vector unsigned int)b);
+                                      (vector unsigned int)__a,
+                                      (vector unsigned int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector bool int a, vector unsigned int b)
+vec_any_le(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)a, b);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector bool int a, vector bool int b)
+vec_any_le(vector bool int __a, vector bool int __b)
 {
   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV,
-                                      (vector unsigned int)a,
-                                      (vector unsigned int)b);
+                                      (vector unsigned int)__a,
+                                      (vector unsigned int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_le(vector float a, vector float b)
+vec_any_le(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, b, a);
+  return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __b, __a);
 }
 
 /* vec_any_lt */
 
 static int __ATTRS_o_ai
-vec_any_lt(vector signed char a, vector signed char b)
+vec_any_lt(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, b, a);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector signed char a, vector bool char b)
+vec_any_lt(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, (vector signed char)b, a);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, (vector signed char)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector unsigned char a, vector unsigned char b)
+vec_any_lt(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, b, a);
+  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector unsigned char a, vector bool char b)
+vec_any_lt(vector unsigned char __a, vector bool char __b)
 {
   return 
-    __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)b, a);
+    __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector bool char a, vector signed char b)
+vec_any_lt(vector bool char __a, vector signed char __b)
 {
   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV,
-                                      (vector unsigned char)b,
-                                      (vector unsigned char)a);
+                                      (vector unsigned char)__b,
+                                      (vector unsigned char)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector bool char a, vector unsigned char b)
+vec_any_lt(vector bool char __a, vector unsigned char __b)
 {
   return 
-    __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, b, (vector unsigned char)a);
+    __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b, (vector unsigned char)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector bool char a, vector bool char b)
+vec_any_lt(vector bool char __a, vector bool char __b)
 {
   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV,
-                                      (vector unsigned char)b,
-                                      (vector unsigned char)a);
+                                      (vector unsigned char)__b,
+                                      (vector unsigned char)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector short a, vector short b)
+vec_any_lt(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, b, a);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector short a, vector bool short b)
+vec_any_lt(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, (vector short)b, a);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, (vector short)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector unsigned short a, vector unsigned short b)
+vec_any_lt(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, b, a);
+  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector unsigned short a, vector bool short b)
+vec_any_lt(vector unsigned short __a, vector bool short __b)
 {
   return 
-    __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)b, a);
+    __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector bool short a, vector short b)
+vec_any_lt(vector bool short __a, vector short __b)
 {
   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV,
-                                      (vector unsigned short)b,
-                                      (vector unsigned short)a);
+                                      (vector unsigned short)__b,
+                                      (vector unsigned short)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector bool short a, vector unsigned short b)
+vec_any_lt(vector bool short __a, vector unsigned short __b)
 {
   return 
-    __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, b, (vector unsigned short)a);
+    __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b, (vector unsigned short)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector bool short a, vector bool short b)
+vec_any_lt(vector bool short __a, vector bool short __b)
 {
   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV,
-                                      (vector unsigned short)b,
-                                      (vector unsigned short)a);
+                                      (vector unsigned short)__b,
+                                      (vector unsigned short)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector int a, vector int b)
+vec_any_lt(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, b, a);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector int a, vector bool int b)
+vec_any_lt(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, (vector int)b, a);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, (vector int)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector unsigned int a, vector unsigned int b)
+vec_any_lt(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, b, a);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector unsigned int a, vector bool int b)
+vec_any_lt(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)b, a);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b, __a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector bool int a, vector int b)
+vec_any_lt(vector bool int __a, vector int __b)
 {
   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV,
-                                      (vector unsigned int)b,
-                                      (vector unsigned int)a);
+                                      (vector unsigned int)__b,
+                                      (vector unsigned int)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector bool int a, vector unsigned int b)
+vec_any_lt(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, b, (vector unsigned int)a);
+  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b, (vector unsigned int)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector bool int a, vector bool int b)
+vec_any_lt(vector bool int __a, vector bool int __b)
 {
   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV,
-                                      (vector unsigned int)b,
-                                      (vector unsigned int)a);
+                                      (vector unsigned int)__b,
+                                      (vector unsigned int)__a);
 }
 
 static int __ATTRS_o_ai
-vec_any_lt(vector float a, vector float b)
+vec_any_lt(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, b, a);
+  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __b, __a);
 }
 
 /* vec_any_nan */
 
 static int __attribute__((__always_inline__))
-vec_any_nan(vector float a)
+vec_any_nan(vector float __a)
 {
-  return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, a, a);
+  return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __a);
 }
 
 /* vec_any_ne */
 
 static int __ATTRS_o_ai
-vec_any_ne(vector signed char a, vector signed char b)
+vec_any_ne(vector signed char __a, vector signed char __b)
 {
   return
-    __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)a, (vector char)b);
+    __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector signed char a, vector bool char b)
+vec_any_ne(vector signed char __a, vector bool char __b)
 {
   return
-    __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)a, (vector char)b);
+    __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector unsigned char a, vector unsigned char b)
+vec_any_ne(vector unsigned char __a, vector unsigned char __b)
 {
   return
-    __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)a, (vector char)b);
+    __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector unsigned char a, vector bool char b)
+vec_any_ne(vector unsigned char __a, vector bool char __b)
 {
   return
-    __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)a, (vector char)b);
+    __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector bool char a, vector signed char b)
+vec_any_ne(vector bool char __a, vector signed char __b)
 {
   return
-    __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)a, (vector char)b);
+    __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector bool char a, vector unsigned char b)
+vec_any_ne(vector bool char __a, vector unsigned char __b)
 {
   return
-    __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)a, (vector char)b);
+    __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector bool char a, vector bool char b)
+vec_any_ne(vector bool char __a, vector bool char __b)
 {
   return
-    __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)a, (vector char)b);
+    __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a, (vector char)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector short a, vector short b)
+vec_any_ne(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, a, b);
+  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector short a, vector bool short b)
+vec_any_ne(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, a, (vector short)b);
+  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector unsigned short a, vector unsigned short b)
+vec_any_ne(vector unsigned short __a, vector unsigned short __b)
 {
   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, 
-                                      (vector short)a,
-                                      (vector short)b);
+                                      (vector short)__a,
+                                      (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector unsigned short a, vector bool short b)
+vec_any_ne(vector unsigned short __a, vector bool short __b)
 {
   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV,
-                                      (vector short)a,
-                                      (vector short)b);
+                                      (vector short)__a,
+                                      (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector bool short a, vector short b)
+vec_any_ne(vector bool short __a, vector short __b)
 {
   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV,
-                                      (vector short)a,
-                                      (vector short)b);
+                                      (vector short)__a,
+                                      (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector bool short a, vector unsigned short b)
+vec_any_ne(vector bool short __a, vector unsigned short __b)
 {
   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV,
-                                      (vector short)a,
-                                      (vector short)b);
+                                      (vector short)__a,
+                                      (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector bool short a, vector bool short b)
+vec_any_ne(vector bool short __a, vector bool short __b)
 {
   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV,
-                                      (vector short)a,
-                                      (vector short)b);
+                                      (vector short)__a,
+                                      (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector pixel a, vector pixel b)
+vec_any_ne(vector pixel __a, vector pixel __b)
 {
   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV,
-                                      (vector short)a,
-                                      (vector short)b);
+                                      (vector short)__a,
+                                      (vector short)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector int a, vector int b)
+vec_any_ne(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, a, b);
+  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, __b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector int a, vector bool int b)
+vec_any_ne(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, a, (vector int)b);
+  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector unsigned int a, vector unsigned int b)
+vec_any_ne(vector unsigned int __a, vector unsigned int __b)
 {
   return
-    __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)a, (vector int)b);
+    __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector unsigned int a, vector bool int b)
+vec_any_ne(vector unsigned int __a, vector bool int __b)
 {
   return
-    __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)a, (vector int)b);
+    __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector bool int a, vector int b)
+vec_any_ne(vector bool int __a, vector int __b)
 {
   return
-    __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)a, (vector int)b);
+    __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector bool int a, vector unsigned int b)
+vec_any_ne(vector bool int __a, vector unsigned int __b)
 {
   return
-    __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)a, (vector int)b);
+    __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector bool int a, vector bool int b)
+vec_any_ne(vector bool int __a, vector bool int __b)
 {
   return
-    __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)a, (vector int)b);
+    __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a, (vector int)__b);
 }
 
 static int __ATTRS_o_ai
-vec_any_ne(vector float a, vector float b)
+vec_any_ne(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, a, b);
+  return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __b);
 }
 
 /* vec_any_nge */
 
 static int __attribute__((__always_inline__))
-vec_any_nge(vector float a, vector float b)
+vec_any_nge(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, a, b);
+  return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __a, __b);
 }
 
 /* vec_any_ngt */
 
 static int __attribute__((__always_inline__))
-vec_any_ngt(vector float a, vector float b)
+vec_any_ngt(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, a, b);
+  return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __a, __b);
 }
 
 /* vec_any_nle */
 
 static int __attribute__((__always_inline__))
-vec_any_nle(vector float a, vector float b)
+vec_any_nle(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, b, a);
+  return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __b, __a);
 }
 
 /* vec_any_nlt */
 
 static int __attribute__((__always_inline__))
-vec_any_nlt(vector float a, vector float b)
+vec_any_nlt(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, b, a);
+  return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __b, __a);
 }
 
 /* vec_any_numeric */
 
 static int __attribute__((__always_inline__))
-vec_any_numeric(vector float a)
+vec_any_numeric(vector float __a)
 {
-  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, a, a);
+  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __a);
 }
 
 /* vec_any_out */
 
 static int __attribute__((__always_inline__))
-vec_any_out(vector float a, vector float b)
+vec_any_out(vector float __a, vector float __b)
 {
-  return __builtin_altivec_vcmpbfp_p(__CR6_EQ_REV, a, b);
+  return __builtin_altivec_vcmpbfp_p(__CR6_EQ_REV, __a, __b);
 }
 
 #undef __ATTRS_o_ai
diff --git a/renderscript/clang-include/avx2intrin.h b/renderscript/clang-include/avx2intrin.h
index 2c53aed..63b1efc 100644
--- a/renderscript/clang-include/avx2intrin.h
+++ b/renderscript/clang-include/avx2intrin.h
@@ -29,39 +29,39 @@
 #define _mm256_mpsadbw_epu8(X, Y, M) __builtin_ia32_mpsadbw256((X), (Y), (M))
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_abs_epi8(__m256i a)
+_mm256_abs_epi8(__m256i __a)
 {
-    return (__m256i)__builtin_ia32_pabsb256((__v32qi)a);
+    return (__m256i)__builtin_ia32_pabsb256((__v32qi)__a);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_abs_epi16(__m256i a)
+_mm256_abs_epi16(__m256i __a)
 {
-    return (__m256i)__builtin_ia32_pabsw256((__v16hi)a);
+    return (__m256i)__builtin_ia32_pabsw256((__v16hi)__a);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_abs_epi32(__m256i a)
+_mm256_abs_epi32(__m256i __a)
 {
-    return (__m256i)__builtin_ia32_pabsd256((__v8si)a);
+    return (__m256i)__builtin_ia32_pabsd256((__v8si)__a);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_packs_epi16(__m256i a, __m256i b)
+_mm256_packs_epi16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_packsswb256((__v16hi)a, (__v16hi)b);
+  return (__m256i)__builtin_ia32_packsswb256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_packs_epi32(__m256i a, __m256i b)
+_mm256_packs_epi32(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_packssdw256((__v8si)a, (__v8si)b);
+  return (__m256i)__builtin_ia32_packssdw256((__v8si)__a, (__v8si)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_packus_epi16(__m256i a, __m256i b)
+_mm256_packus_epi16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_packuswb256((__v16hi)a, (__v16hi)b);
+  return (__m256i)__builtin_ia32_packuswb256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
@@ -71,51 +71,51 @@
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_add_epi8(__m256i a, __m256i b)
+_mm256_add_epi8(__m256i __a, __m256i __b)
 {
-  return (__m256i)((__v32qi)a + (__v32qi)b);
+  return (__m256i)((__v32qi)__a + (__v32qi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_add_epi16(__m256i a, __m256i b)
+_mm256_add_epi16(__m256i __a, __m256i __b)
 {
-  return (__m256i)((__v16hi)a + (__v16hi)b);
+  return (__m256i)((__v16hi)__a + (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_add_epi32(__m256i a, __m256i b)
+_mm256_add_epi32(__m256i __a, __m256i __b)
 {
-  return (__m256i)((__v8si)a + (__v8si)b);
+  return (__m256i)((__v8si)__a + (__v8si)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_add_epi64(__m256i a, __m256i b)
+_mm256_add_epi64(__m256i __a, __m256i __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_adds_epi8(__m256i a, __m256i b)
+_mm256_adds_epi8(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_paddsb256((__v32qi)a, (__v32qi)b);
+  return (__m256i)__builtin_ia32_paddsb256((__v32qi)__a, (__v32qi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_adds_epi16(__m256i a, __m256i b)
+_mm256_adds_epi16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_paddsw256((__v16hi)a, (__v16hi)b);
+  return (__m256i)__builtin_ia32_paddsw256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_adds_epu8(__m256i a, __m256i b)
+_mm256_adds_epu8(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_paddusb256((__v32qi)a, (__v32qi)b);
+  return (__m256i)__builtin_ia32_paddusb256((__v32qi)__a, (__v32qi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_adds_epu16(__m256i a, __m256i b)
+_mm256_adds_epu16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_paddusw256((__v16hi)a, (__v16hi)b);
+  return (__m256i)__builtin_ia32_paddusw256((__v16hi)__a, (__v16hi)__b);
 }
 
 #define _mm256_alignr_epi8(a, b, n) __extension__ ({ \
@@ -124,27 +124,27 @@
   (__m256i)__builtin_ia32_palignr256((__v32qi)__a, (__v32qi)__b, (n)); })
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_and_si256(__m256i a, __m256i b)
+_mm256_and_si256(__m256i __a, __m256i __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_andnot_si256(__m256i a, __m256i b)
+_mm256_andnot_si256(__m256i __a, __m256i __b)
 {
-  return ~a & b;
+  return ~__a & __b;
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_avg_epu8(__m256i a, __m256i b)
+_mm256_avg_epu8(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pavgb256((__v32qi)a, (__v32qi)b);
+  return (__m256i)__builtin_ia32_pavgb256((__v32qi)__a, (__v32qi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_avg_epu16(__m256i a, __m256i b)
+_mm256_avg_epu16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pavgw256((__v16hi)a, (__v16hi)b);
+  return (__m256i)__builtin_ia32_pavgw256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
@@ -160,177 +160,177 @@
   (__m256i)__builtin_ia32_pblendw256((__v16hi)__V1, (__v16hi)__V2, (M)); })
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_cmpeq_epi8(__m256i a, __m256i b)
+_mm256_cmpeq_epi8(__m256i __a, __m256i __b)
 {
-  return (__m256i)((__v32qi)a == (__v32qi)b);
+  return (__m256i)((__v32qi)__a == (__v32qi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_cmpeq_epi16(__m256i a, __m256i b)
+_mm256_cmpeq_epi16(__m256i __a, __m256i __b)
 {
-  return (__m256i)((__v16hi)a == (__v16hi)b);
+  return (__m256i)((__v16hi)__a == (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_cmpeq_epi32(__m256i a, __m256i b)
+_mm256_cmpeq_epi32(__m256i __a, __m256i __b)
 {
-  return (__m256i)((__v8si)a == (__v8si)b);
+  return (__m256i)((__v8si)__a == (__v8si)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_cmpeq_epi64(__m256i a, __m256i b)
+_mm256_cmpeq_epi64(__m256i __a, __m256i __b)
 {
-  return (__m256i)(a == b);
+  return (__m256i)(__a == __b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_cmpgt_epi8(__m256i a, __m256i b)
+_mm256_cmpgt_epi8(__m256i __a, __m256i __b)
 {
-  return (__m256i)((__v32qi)a > (__v32qi)b);
+  return (__m256i)((__v32qi)__a > (__v32qi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_cmpgt_epi16(__m256i a, __m256i b)
+_mm256_cmpgt_epi16(__m256i __a, __m256i __b)
 {
-  return (__m256i)((__v16hi)a > (__v16hi)b);
+  return (__m256i)((__v16hi)__a > (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_cmpgt_epi32(__m256i a, __m256i b)
+_mm256_cmpgt_epi32(__m256i __a, __m256i __b)
 {
-  return (__m256i)((__v8si)a > (__v8si)b);
+  return (__m256i)((__v8si)__a > (__v8si)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_cmpgt_epi64(__m256i a, __m256i b)
+_mm256_cmpgt_epi64(__m256i __a, __m256i __b)
 {
-  return (__m256i)(a > b);
+  return (__m256i)(__a > __b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_hadd_epi16(__m256i a, __m256i b)
+_mm256_hadd_epi16(__m256i __a, __m256i __b)
 {
-    return (__m256i)__builtin_ia32_phaddw256((__v16hi)a, (__v16hi)b);
+    return (__m256i)__builtin_ia32_phaddw256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_hadd_epi32(__m256i a, __m256i b)
+_mm256_hadd_epi32(__m256i __a, __m256i __b)
 {
-    return (__m256i)__builtin_ia32_phaddd256((__v8si)a, (__v8si)b);
+    return (__m256i)__builtin_ia32_phaddd256((__v8si)__a, (__v8si)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_hadds_epi16(__m256i a, __m256i b)
+_mm256_hadds_epi16(__m256i __a, __m256i __b)
 {
-    return (__m256i)__builtin_ia32_phaddsw256((__v16hi)a, (__v16hi)b);
+    return (__m256i)__builtin_ia32_phaddsw256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_hsub_epi16(__m256i a, __m256i b)
+_mm256_hsub_epi16(__m256i __a, __m256i __b)
 {
-    return (__m256i)__builtin_ia32_phsubw256((__v16hi)a, (__v16hi)b);
+    return (__m256i)__builtin_ia32_phsubw256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_hsub_epi32(__m256i a, __m256i b)
+_mm256_hsub_epi32(__m256i __a, __m256i __b)
 {
-    return (__m256i)__builtin_ia32_phsubd256((__v8si)a, (__v8si)b);
+    return (__m256i)__builtin_ia32_phsubd256((__v8si)__a, (__v8si)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_hsubs_epi16(__m256i a, __m256i b)
+_mm256_hsubs_epi16(__m256i __a, __m256i __b)
 {
-    return (__m256i)__builtin_ia32_phsubsw256((__v16hi)a, (__v16hi)b);
+    return (__m256i)__builtin_ia32_phsubsw256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_maddubs_epi16(__m256i a, __m256i b)
+_mm256_maddubs_epi16(__m256i __a, __m256i __b)
 {
-    return (__m256i)__builtin_ia32_pmaddubsw256((__v32qi)a, (__v32qi)b);
+    return (__m256i)__builtin_ia32_pmaddubsw256((__v32qi)__a, (__v32qi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_madd_epi16(__m256i a, __m256i b)
+_mm256_madd_epi16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pmaddwd256((__v16hi)a, (__v16hi)b);
+  return (__m256i)__builtin_ia32_pmaddwd256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_max_epi8(__m256i a, __m256i b)
+_mm256_max_epi8(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pmaxsb256((__v32qi)a, (__v32qi)b);
+  return (__m256i)__builtin_ia32_pmaxsb256((__v32qi)__a, (__v32qi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_max_epi16(__m256i a, __m256i b)
+_mm256_max_epi16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pmaxsw256((__v16hi)a, (__v16hi)b);
+  return (__m256i)__builtin_ia32_pmaxsw256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_max_epi32(__m256i a, __m256i b)
+_mm256_max_epi32(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pmaxsd256((__v8si)a, (__v8si)b);
+  return (__m256i)__builtin_ia32_pmaxsd256((__v8si)__a, (__v8si)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_max_epu8(__m256i a, __m256i b)
+_mm256_max_epu8(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pmaxub256((__v32qi)a, (__v32qi)b);
+  return (__m256i)__builtin_ia32_pmaxub256((__v32qi)__a, (__v32qi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_max_epu16(__m256i a, __m256i b)
+_mm256_max_epu16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pmaxuw256((__v16hi)a, (__v16hi)b);
+  return (__m256i)__builtin_ia32_pmaxuw256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_max_epu32(__m256i a, __m256i b)
+_mm256_max_epu32(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pmaxud256((__v8si)a, (__v8si)b);
+  return (__m256i)__builtin_ia32_pmaxud256((__v8si)__a, (__v8si)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_min_epi8(__m256i a, __m256i b)
+_mm256_min_epi8(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pminsb256((__v32qi)a, (__v32qi)b);
+  return (__m256i)__builtin_ia32_pminsb256((__v32qi)__a, (__v32qi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_min_epi16(__m256i a, __m256i b)
+_mm256_min_epi16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pminsw256((__v16hi)a, (__v16hi)b);
+  return (__m256i)__builtin_ia32_pminsw256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_min_epi32(__m256i a, __m256i b)
+_mm256_min_epi32(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pminsd256((__v8si)a, (__v8si)b);
+  return (__m256i)__builtin_ia32_pminsd256((__v8si)__a, (__v8si)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_min_epu8(__m256i a, __m256i b)
+_mm256_min_epu8(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pminub256((__v32qi)a, (__v32qi)b);
+  return (__m256i)__builtin_ia32_pminub256((__v32qi)__a, (__v32qi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_min_epu16(__m256i a, __m256i b)
+_mm256_min_epu16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pminuw256 ((__v16hi)a, (__v16hi)b);
+  return (__m256i)__builtin_ia32_pminuw256 ((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_min_epu32(__m256i a, __m256i b)
+_mm256_min_epu32(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pminud256((__v8si)a, (__v8si)b);
+  return (__m256i)__builtin_ia32_pminud256((__v8si)__a, (__v8si)__b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm256_movemask_epi8(__m256i a)
+_mm256_movemask_epi8(__m256i __a)
 {
-  return __builtin_ia32_pmovmskb256((__v32qi)a);
+  return __builtin_ia32_pmovmskb256((__v32qi)__a);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
@@ -406,63 +406,63 @@
 }
 
 static __inline__  __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_mul_epi32(__m256i a, __m256i b)
+_mm256_mul_epi32(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pmuldq256((__v8si)a, (__v8si)b);
+  return (__m256i)__builtin_ia32_pmuldq256((__v8si)__a, (__v8si)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_mulhrs_epi16(__m256i a, __m256i b)
+_mm256_mulhrs_epi16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pmulhrsw256((__v16hi)a, (__v16hi)b);
+  return (__m256i)__builtin_ia32_pmulhrsw256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_mulhi_epu16(__m256i a, __m256i b)
+_mm256_mulhi_epu16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pmulhuw256((__v16hi)a, (__v16hi)b);
+  return (__m256i)__builtin_ia32_pmulhuw256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_mulhi_epi16(__m256i a, __m256i b)
+_mm256_mulhi_epi16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pmulhw256((__v16hi)a, (__v16hi)b);
+  return (__m256i)__builtin_ia32_pmulhw256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_mullo_epi16(__m256i a, __m256i b)
+_mm256_mullo_epi16(__m256i __a, __m256i __b)
 {
-  return (__m256i)((__v16hi)a * (__v16hi)b);
+  return (__m256i)((__v16hi)__a * (__v16hi)__b);
 }
 
 static __inline__  __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_mullo_epi32 (__m256i a, __m256i b)
+_mm256_mullo_epi32 (__m256i __a, __m256i __b)
 {
-  return (__m256i)((__v8si)a * (__v8si)b);
+  return (__m256i)((__v8si)__a * (__v8si)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_mul_epu32(__m256i a, __m256i b)
+_mm256_mul_epu32(__m256i __a, __m256i __b)
 {
-  return __builtin_ia32_pmuludq256((__v8si)a, (__v8si)b);
+  return __builtin_ia32_pmuludq256((__v8si)__a, (__v8si)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_or_si256(__m256i a, __m256i b)
+_mm256_or_si256(__m256i __a, __m256i __b)
 {
-  return a | b;
+  return __a | __b;
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_sad_epu8(__m256i a, __m256i b)
+_mm256_sad_epu8(__m256i __a, __m256i __b)
 {
-  return __builtin_ia32_psadbw256((__v32qi)a, (__v32qi)b);
+  return __builtin_ia32_psadbw256((__v32qi)__a, (__v32qi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_shuffle_epi8(__m256i a, __m256i b)
+_mm256_shuffle_epi8(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_pshufb256((__v32qi)a, (__v32qi)b);
+  return (__m256i)__builtin_ia32_pshufb256((__v32qi)__a, (__v32qi)__b);
 }
 
 #define _mm256_shuffle_epi32(a, imm) __extension__ ({ \
@@ -502,21 +502,21 @@
                                    12, 13, 14, 15); })
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_sign_epi8(__m256i a, __m256i b)
+_mm256_sign_epi8(__m256i __a, __m256i __b)
 {
-    return (__m256i)__builtin_ia32_psignb256((__v32qi)a, (__v32qi)b);
+    return (__m256i)__builtin_ia32_psignb256((__v32qi)__a, (__v32qi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_sign_epi16(__m256i a, __m256i b)
+_mm256_sign_epi16(__m256i __a, __m256i __b)
 {
-    return (__m256i)__builtin_ia32_psignw256((__v16hi)a, (__v16hi)b);
+    return (__m256i)__builtin_ia32_psignw256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_sign_epi32(__m256i a, __m256i b)
+_mm256_sign_epi32(__m256i __a, __m256i __b)
 {
-    return (__m256i)__builtin_ia32_psignd256((__v8si)a, (__v8si)b);
+    return (__m256i)__builtin_ia32_psignd256((__v8si)__a, (__v8si)__b);
 }
 
 #define _mm256_slli_si256(a, count) __extension__ ({ \
@@ -524,63 +524,63 @@
   (__m256i)__builtin_ia32_pslldqi256(__a, (count)*8); })
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_slli_epi16(__m256i a, int count)
+_mm256_slli_epi16(__m256i __a, int __count)
 {
-  return (__m256i)__builtin_ia32_psllwi256((__v16hi)a, count);
+  return (__m256i)__builtin_ia32_psllwi256((__v16hi)__a, __count);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_sll_epi16(__m256i a, __m128i count)
+_mm256_sll_epi16(__m256i __a, __m128i __count)
 {
-  return (__m256i)__builtin_ia32_psllw256((__v16hi)a, (__v8hi)count);
+  return (__m256i)__builtin_ia32_psllw256((__v16hi)__a, (__v8hi)__count);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_slli_epi32(__m256i a, int count)
+_mm256_slli_epi32(__m256i __a, int __count)
 {
-  return (__m256i)__builtin_ia32_pslldi256((__v8si)a, count);
+  return (__m256i)__builtin_ia32_pslldi256((__v8si)__a, __count);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_sll_epi32(__m256i a, __m128i count)
+_mm256_sll_epi32(__m256i __a, __m128i __count)
 {
-  return (__m256i)__builtin_ia32_pslld256((__v8si)a, (__v4si)count);
+  return (__m256i)__builtin_ia32_pslld256((__v8si)__a, (__v4si)__count);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_slli_epi64(__m256i a, int count)
+_mm256_slli_epi64(__m256i __a, int __count)
 {
-  return __builtin_ia32_psllqi256(a, count);
+  return __builtin_ia32_psllqi256(__a, __count);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_sll_epi64(__m256i a, __m128i count)
+_mm256_sll_epi64(__m256i __a, __m128i __count)
 {
-  return __builtin_ia32_psllq256(a, count);
+  return __builtin_ia32_psllq256(__a, __count);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_srai_epi16(__m256i a, int count)
+_mm256_srai_epi16(__m256i __a, int __count)
 {
-  return (__m256i)__builtin_ia32_psrawi256((__v16hi)a, count);
+  return (__m256i)__builtin_ia32_psrawi256((__v16hi)__a, __count);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_sra_epi16(__m256i a, __m128i count)
+_mm256_sra_epi16(__m256i __a, __m128i __count)
 {
-  return (__m256i)__builtin_ia32_psraw256((__v16hi)a, (__v8hi)count);
+  return (__m256i)__builtin_ia32_psraw256((__v16hi)__a, (__v8hi)__count);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_srai_epi32(__m256i a, int count)
+_mm256_srai_epi32(__m256i __a, int __count)
 {
-  return (__m256i)__builtin_ia32_psradi256((__v8si)a, count);
+  return (__m256i)__builtin_ia32_psradi256((__v8si)__a, __count);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_sra_epi32(__m256i a, __m128i count)
+_mm256_sra_epi32(__m256i __a, __m128i __count)
 {
-  return (__m256i)__builtin_ia32_psrad256((__v8si)a, (__v4si)count);
+  return (__m256i)__builtin_ia32_psrad256((__v8si)__a, (__v4si)__count);
 }
 
 #define _mm256_srli_si256(a, count) __extension__ ({ \
@@ -588,141 +588,141 @@
   (__m256i)__builtin_ia32_psrldqi256(__a, (count)*8); })
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_srli_epi16(__m256i a, int count)
+_mm256_srli_epi16(__m256i __a, int __count)
 {
-  return (__m256i)__builtin_ia32_psrlwi256((__v16hi)a, count);
+  return (__m256i)__builtin_ia32_psrlwi256((__v16hi)__a, __count);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_srl_epi16(__m256i a, __m128i count)
+_mm256_srl_epi16(__m256i __a, __m128i __count)
 {
-  return (__m256i)__builtin_ia32_psrlw256((__v16hi)a, (__v8hi)count);
+  return (__m256i)__builtin_ia32_psrlw256((__v16hi)__a, (__v8hi)__count);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_srli_epi32(__m256i a, int count)
+_mm256_srli_epi32(__m256i __a, int __count)
 {
-  return (__m256i)__builtin_ia32_psrldi256((__v8si)a, count);
+  return (__m256i)__builtin_ia32_psrldi256((__v8si)__a, __count);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_srl_epi32(__m256i a, __m128i count)
+_mm256_srl_epi32(__m256i __a, __m128i __count)
 {
-  return (__m256i)__builtin_ia32_psrld256((__v8si)a, (__v4si)count);
+  return (__m256i)__builtin_ia32_psrld256((__v8si)__a, (__v4si)__count);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_srli_epi64(__m256i a, int count)
+_mm256_srli_epi64(__m256i __a, int __count)
 {
-  return __builtin_ia32_psrlqi256(a, count);
+  return __builtin_ia32_psrlqi256(__a, __count);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_srl_epi64(__m256i a, __m128i count)
+_mm256_srl_epi64(__m256i __a, __m128i __count)
 {
-  return __builtin_ia32_psrlq256(a, count);
+  return __builtin_ia32_psrlq256(__a, __count);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_sub_epi8(__m256i a, __m256i b)
+_mm256_sub_epi8(__m256i __a, __m256i __b)
 {
-  return (__m256i)((__v32qi)a - (__v32qi)b);
+  return (__m256i)((__v32qi)__a - (__v32qi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_sub_epi16(__m256i a, __m256i b)
+_mm256_sub_epi16(__m256i __a, __m256i __b)
 {
-  return (__m256i)((__v16hi)a - (__v16hi)b);
+  return (__m256i)((__v16hi)__a - (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_sub_epi32(__m256i a, __m256i b)
+_mm256_sub_epi32(__m256i __a, __m256i __b)
 {
-  return (__m256i)((__v8si)a - (__v8si)b);
+  return (__m256i)((__v8si)__a - (__v8si)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_sub_epi64(__m256i a, __m256i b)
+_mm256_sub_epi64(__m256i __a, __m256i __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_subs_epi8(__m256i a, __m256i b)
+_mm256_subs_epi8(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_psubsb256((__v32qi)a, (__v32qi)b);
+  return (__m256i)__builtin_ia32_psubsb256((__v32qi)__a, (__v32qi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_subs_epi16(__m256i a, __m256i b)
+_mm256_subs_epi16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_psubsw256((__v16hi)a, (__v16hi)b);
+  return (__m256i)__builtin_ia32_psubsw256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_subs_epu8(__m256i a, __m256i b)
+_mm256_subs_epu8(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_psubusb256((__v32qi)a, (__v32qi)b);
+  return (__m256i)__builtin_ia32_psubusb256((__v32qi)__a, (__v32qi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_subs_epu16(__m256i a, __m256i b)
+_mm256_subs_epu16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_psubusw256((__v16hi)a, (__v16hi)b);
+  return (__m256i)__builtin_ia32_psubusw256((__v16hi)__a, (__v16hi)__b);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_unpackhi_epi8(__m256i a, __m256i b)
+_mm256_unpackhi_epi8(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_shufflevector((__v32qi)a, (__v32qi)b, 8, 32+8, 9, 32+9, 10, 32+10, 11, 32+11, 12, 32+12, 13, 32+13, 14, 32+14, 15, 32+15, 24, 32+24, 25, 32+25, 26, 32+26, 27, 32+27, 28, 32+28, 29, 32+29, 30, 32+30, 31, 32+31);
+  return (__m256i)__builtin_shufflevector((__v32qi)__a, (__v32qi)__b, 8, 32+8, 9, 32+9, 10, 32+10, 11, 32+11, 12, 32+12, 13, 32+13, 14, 32+14, 15, 32+15, 24, 32+24, 25, 32+25, 26, 32+26, 27, 32+27, 28, 32+28, 29, 32+29, 30, 32+30, 31, 32+31);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_unpackhi_epi16(__m256i a, __m256i b)
+_mm256_unpackhi_epi16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_shufflevector((__v16hi)a, (__v16hi)b, 4, 16+4, 5, 16+5, 6, 16+6, 7, 16+7, 12, 16+12, 13, 16+13, 14, 16+14, 15, 16+15);
+  return (__m256i)__builtin_shufflevector((__v16hi)__a, (__v16hi)__b, 4, 16+4, 5, 16+5, 6, 16+6, 7, 16+7, 12, 16+12, 13, 16+13, 14, 16+14, 15, 16+15);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_unpackhi_epi32(__m256i a, __m256i b)
+_mm256_unpackhi_epi32(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_shufflevector((__v8si)a, (__v8si)b, 2, 8+2, 3, 8+3, 6, 8+6, 7, 8+7);
+  return (__m256i)__builtin_shufflevector((__v8si)__a, (__v8si)__b, 2, 8+2, 3, 8+3, 6, 8+6, 7, 8+7);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_unpackhi_epi64(__m256i a, __m256i b)
+_mm256_unpackhi_epi64(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_shufflevector(a, b, 1, 4+1, 3, 4+3);
+  return (__m256i)__builtin_shufflevector(__a, __b, 1, 4+1, 3, 4+3);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_unpacklo_epi8(__m256i a, __m256i b)
+_mm256_unpacklo_epi8(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_shufflevector((__v32qi)a, (__v32qi)b, 0, 32+0, 1, 32+1, 2, 32+2, 3, 32+3, 4, 32+4, 5, 32+5, 6, 32+6, 7, 32+7, 16, 32+16, 17, 32+17, 18, 32+18, 19, 32+19, 20, 32+20, 21, 32+21, 22, 32+22, 23, 32+23);
+  return (__m256i)__builtin_shufflevector((__v32qi)__a, (__v32qi)__b, 0, 32+0, 1, 32+1, 2, 32+2, 3, 32+3, 4, 32+4, 5, 32+5, 6, 32+6, 7, 32+7, 16, 32+16, 17, 32+17, 18, 32+18, 19, 32+19, 20, 32+20, 21, 32+21, 22, 32+22, 23, 32+23);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_unpacklo_epi16(__m256i a, __m256i b)
+_mm256_unpacklo_epi16(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_shufflevector((__v16hi)a, (__v16hi)b, 0, 16+0, 1, 16+1, 2, 16+2, 3, 16+3, 8, 16+8, 9, 16+9, 10, 16+10, 11, 16+11);
+  return (__m256i)__builtin_shufflevector((__v16hi)__a, (__v16hi)__b, 0, 16+0, 1, 16+1, 2, 16+2, 3, 16+3, 8, 16+8, 9, 16+9, 10, 16+10, 11, 16+11);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_unpacklo_epi32(__m256i a, __m256i b)
+_mm256_unpacklo_epi32(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_shufflevector((__v8si)a, (__v8si)b, 0, 8+0, 1, 8+1, 4, 8+4, 5, 8+5);
+  return (__m256i)__builtin_shufflevector((__v8si)__a, (__v8si)__b, 0, 8+0, 1, 8+1, 4, 8+4, 5, 8+5);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_unpacklo_epi64(__m256i a, __m256i b)
+_mm256_unpacklo_epi64(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_shufflevector(a, b, 0, 4+0, 2, 4+2);
+  return (__m256i)__builtin_shufflevector(__a, __b, 0, 4+0, 2, 4+2);
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_xor_si256(__m256i a, __m256i b)
+_mm256_xor_si256(__m256i __a, __m256i __b)
 {
-  return a ^ b;
+  return __a ^ __b;
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
@@ -750,9 +750,9 @@
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm_broadcastsi128_si256(__m128i const *a)
+_mm_broadcastsi128_si256(__m128i const *__a)
 {
-  return (__m256i)__builtin_ia32_vbroadcastsi256(a);
+  return (__m256i)__builtin_ia32_vbroadcastsi256(__a);
 }
 
 #define _mm_blend_epi32(V1, V2, M) __extension__ ({ \
@@ -815,9 +815,9 @@
 }
 
 static __inline__ __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_permutevar8x32_epi32(__m256i a, __m256i b)
+_mm256_permutevar8x32_epi32(__m256i __a, __m256i __b)
 {
-  return (__m256i)__builtin_ia32_permvarsi256((__v8si)a, (__v8si)b);
+  return (__m256i)__builtin_ia32_permvarsi256((__v8si)__a, (__v8si)__b);
 }
 
 #define _mm256_permute4x64_pd(V, M) __extension__ ({ \
@@ -827,9 +827,9 @@
                                    ((M) & 0x30) >> 4, ((M) & 0xc0) >> 6); })
 
 static __inline__ __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_permutevar8x32_ps(__m256 a, __m256 b)
+_mm256_permutevar8x32_ps(__m256 __a, __m256 __b)
 {
-  return (__m256)__builtin_ia32_permvarsf256((__v8sf)a, (__v8sf)b);
+  return (__m256)__builtin_ia32_permvarsf256((__v8sf)__a, (__v8sf)__b);
 }
 
 #define _mm256_permute4x64_epi64(V, M) __extension__ ({ \
diff --git a/renderscript/clang-include/avxintrin.h b/renderscript/clang-include/avxintrin.h
index ee7f835..412d284 100644
--- a/renderscript/clang-include/avxintrin.h
+++ b/renderscript/clang-include/avxintrin.h
@@ -38,111 +38,111 @@
 
 /* Arithmetic */
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_add_pd(__m256d a, __m256d b)
+_mm256_add_pd(__m256d __a, __m256d __b)
 {
-  return a+b;
+  return __a+__b;
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_add_ps(__m256 a, __m256 b)
+_mm256_add_ps(__m256 __a, __m256 __b)
 {
-  return a+b;
+  return __a+__b;
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_sub_pd(__m256d a, __m256d b)
+_mm256_sub_pd(__m256d __a, __m256d __b)
 {
-  return a-b;
+  return __a-__b;
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_sub_ps(__m256 a, __m256 b)
+_mm256_sub_ps(__m256 __a, __m256 __b)
 {
-  return a-b;
+  return __a-__b;
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_addsub_pd(__m256d a, __m256d b)
+_mm256_addsub_pd(__m256d __a, __m256d __b)
 {
-  return (__m256d)__builtin_ia32_addsubpd256((__v4df)a, (__v4df)b);
+  return (__m256d)__builtin_ia32_addsubpd256((__v4df)__a, (__v4df)__b);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_addsub_ps(__m256 a, __m256 b)
+_mm256_addsub_ps(__m256 __a, __m256 __b)
 {
-  return (__m256)__builtin_ia32_addsubps256((__v8sf)a, (__v8sf)b);
+  return (__m256)__builtin_ia32_addsubps256((__v8sf)__a, (__v8sf)__b);
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_div_pd(__m256d a, __m256d b)
+_mm256_div_pd(__m256d __a, __m256d __b)
 {
-  return a / b;
+  return __a / __b;
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_div_ps(__m256 a, __m256 b)
+_mm256_div_ps(__m256 __a, __m256 __b)
 {
-  return a / b;
+  return __a / __b;
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_max_pd(__m256d a, __m256d b)
+_mm256_max_pd(__m256d __a, __m256d __b)
 {
-  return (__m256d)__builtin_ia32_maxpd256((__v4df)a, (__v4df)b);
+  return (__m256d)__builtin_ia32_maxpd256((__v4df)__a, (__v4df)__b);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_max_ps(__m256 a, __m256 b)
+_mm256_max_ps(__m256 __a, __m256 __b)
 {
-  return (__m256)__builtin_ia32_maxps256((__v8sf)a, (__v8sf)b);
+  return (__m256)__builtin_ia32_maxps256((__v8sf)__a, (__v8sf)__b);
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_min_pd(__m256d a, __m256d b)
+_mm256_min_pd(__m256d __a, __m256d __b)
 {
-  return (__m256d)__builtin_ia32_minpd256((__v4df)a, (__v4df)b);
+  return (__m256d)__builtin_ia32_minpd256((__v4df)__a, (__v4df)__b);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_min_ps(__m256 a, __m256 b)
+_mm256_min_ps(__m256 __a, __m256 __b)
 {
-  return (__m256)__builtin_ia32_minps256((__v8sf)a, (__v8sf)b);
+  return (__m256)__builtin_ia32_minps256((__v8sf)__a, (__v8sf)__b);
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_mul_pd(__m256d a, __m256d b)
+_mm256_mul_pd(__m256d __a, __m256d __b)
 {
-  return a * b;
+  return __a * __b;
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_mul_ps(__m256 a, __m256 b)
+_mm256_mul_ps(__m256 __a, __m256 __b)
 {
-  return a * b;
+  return __a * __b;
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_sqrt_pd(__m256d a)
+_mm256_sqrt_pd(__m256d __a)
 {
-  return (__m256d)__builtin_ia32_sqrtpd256((__v4df)a);
+  return (__m256d)__builtin_ia32_sqrtpd256((__v4df)__a);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_sqrt_ps(__m256 a)
+_mm256_sqrt_ps(__m256 __a)
 {
-  return (__m256)__builtin_ia32_sqrtps256((__v8sf)a);
+  return (__m256)__builtin_ia32_sqrtps256((__v8sf)__a);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_rsqrt_ps(__m256 a)
+_mm256_rsqrt_ps(__m256 __a)
 {
-  return (__m256)__builtin_ia32_rsqrtps256((__v8sf)a);
+  return (__m256)__builtin_ia32_rsqrtps256((__v8sf)__a);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_rcp_ps(__m256 a)
+_mm256_rcp_ps(__m256 __a)
 {
-  return (__m256)__builtin_ia32_rcpps256((__v8sf)a);
+  return (__m256)__builtin_ia32_rcpps256((__v8sf)__a);
 }
 
 #define _mm256_round_pd(V, M) __extension__ ({ \
@@ -160,102 +160,102 @@
 
 /* Logical */
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_and_pd(__m256d a, __m256d b)
+_mm256_and_pd(__m256d __a, __m256d __b)
 {
-  return (__m256d)((__v4di)a & (__v4di)b);
+  return (__m256d)((__v4di)__a & (__v4di)__b);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_and_ps(__m256 a, __m256 b)
+_mm256_and_ps(__m256 __a, __m256 __b)
 {
-  return (__m256)((__v8si)a & (__v8si)b);
+  return (__m256)((__v8si)__a & (__v8si)__b);
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_andnot_pd(__m256d a, __m256d b)
+_mm256_andnot_pd(__m256d __a, __m256d __b)
 {
-  return (__m256d)(~(__v4di)a & (__v4di)b);
+  return (__m256d)(~(__v4di)__a & (__v4di)__b);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_andnot_ps(__m256 a, __m256 b)
+_mm256_andnot_ps(__m256 __a, __m256 __b)
 {
-  return (__m256)(~(__v8si)a & (__v8si)b);
+  return (__m256)(~(__v8si)__a & (__v8si)__b);
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_or_pd(__m256d a, __m256d b)
+_mm256_or_pd(__m256d __a, __m256d __b)
 {
-  return (__m256d)((__v4di)a | (__v4di)b);
+  return (__m256d)((__v4di)__a | (__v4di)__b);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_or_ps(__m256 a, __m256 b)
+_mm256_or_ps(__m256 __a, __m256 __b)
 {
-  return (__m256)((__v8si)a | (__v8si)b);
+  return (__m256)((__v8si)__a | (__v8si)__b);
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_xor_pd(__m256d a, __m256d b)
+_mm256_xor_pd(__m256d __a, __m256d __b)
 {
-  return (__m256d)((__v4di)a ^ (__v4di)b);
+  return (__m256d)((__v4di)__a ^ (__v4di)__b);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_xor_ps(__m256 a, __m256 b)
+_mm256_xor_ps(__m256 __a, __m256 __b)
 {
-  return (__m256)((__v8si)a ^ (__v8si)b);
+  return (__m256)((__v8si)__a ^ (__v8si)__b);
 }
 
 /* Horizontal arithmetic */
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_hadd_pd(__m256d a, __m256d b)
+_mm256_hadd_pd(__m256d __a, __m256d __b)
 {
-  return (__m256d)__builtin_ia32_haddpd256((__v4df)a, (__v4df)b);
+  return (__m256d)__builtin_ia32_haddpd256((__v4df)__a, (__v4df)__b);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_hadd_ps(__m256 a, __m256 b)
+_mm256_hadd_ps(__m256 __a, __m256 __b)
 {
-  return (__m256)__builtin_ia32_haddps256((__v8sf)a, (__v8sf)b);
+  return (__m256)__builtin_ia32_haddps256((__v8sf)__a, (__v8sf)__b);
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_hsub_pd(__m256d a, __m256d b)
+_mm256_hsub_pd(__m256d __a, __m256d __b)
 {
-  return (__m256d)__builtin_ia32_hsubpd256((__v4df)a, (__v4df)b);
+  return (__m256d)__builtin_ia32_hsubpd256((__v4df)__a, (__v4df)__b);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_hsub_ps(__m256 a, __m256 b)
+_mm256_hsub_ps(__m256 __a, __m256 __b)
 {
-  return (__m256)__builtin_ia32_hsubps256((__v8sf)a, (__v8sf)b);
+  return (__m256)__builtin_ia32_hsubps256((__v8sf)__a, (__v8sf)__b);
 }
 
 /* Vector permutations */
 static __inline __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_permutevar_pd(__m128d a, __m128i c)
+_mm_permutevar_pd(__m128d __a, __m128i __c)
 {
-  return (__m128d)__builtin_ia32_vpermilvarpd((__v2df)a, (__v2di)c);
+  return (__m128d)__builtin_ia32_vpermilvarpd((__v2df)__a, (__v2di)__c);
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_permutevar_pd(__m256d a, __m256i c)
+_mm256_permutevar_pd(__m256d __a, __m256i __c)
 {
-  return (__m256d)__builtin_ia32_vpermilvarpd256((__v4df)a, (__v4di)c);
+  return (__m256d)__builtin_ia32_vpermilvarpd256((__v4df)__a, (__v4di)__c);
 }
 
 static __inline __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_permutevar_ps(__m128 a, __m128i c)
+_mm_permutevar_ps(__m128 __a, __m128i __c)
 {
-  return (__m128)__builtin_ia32_vpermilvarps((__v4sf)a, (__v4si)c);
+  return (__m128)__builtin_ia32_vpermilvarps((__v4sf)__a, (__v4si)__c);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_permutevar_ps(__m256 a, __m256i c)
+_mm256_permutevar_ps(__m256 __a, __m256i __c)
 {
-  return (__m256)__builtin_ia32_vpermilvarps256((__v8sf)a,
-						  (__v8si)c);
+  return (__m256)__builtin_ia32_vpermilvarps256((__v8sf)__a,
+						  (__v8si)__c);
 }
 
 #define _mm_permute_pd(A, C) __extension__ ({ \
@@ -313,15 +313,17 @@
   (__m256)__builtin_ia32_blendps256((__v8sf)__V1, (__v8sf)__V2, (M)); })
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_blendv_pd(__m256d a, __m256d b, __m256d c)
+_mm256_blendv_pd(__m256d __a, __m256d __b, __m256d __c)
 {
-  return (__m256d)__builtin_ia32_blendvpd256((__v4df)a, (__v4df)b, (__v4df)c);
+  return (__m256d)__builtin_ia32_blendvpd256(
+    (__v4df)__a, (__v4df)__b, (__v4df)__c);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_blendv_ps(__m256 a, __m256 b, __m256 c)
+_mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 {
-  return (__m256)__builtin_ia32_blendvps256((__v8sf)a, (__v8sf)b, (__v8sf)c);
+  return (__m256)__builtin_ia32_blendvps256(
+    (__v8sf)__a, (__v8sf)__b, (__v8sf)__c);
 }
 
 /* Vector Dot Product */
@@ -427,32 +429,32 @@
   (__m128i)__builtin_ia32_vextractf128_si256((__v8si)__A, (O)); })
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm256_extract_epi32(__m256i a, int const imm)
+_mm256_extract_epi32(__m256i __a, int const __imm)
 {
-  __v8si b = (__v8si)a;
-  return b[imm];
+  __v8si __b = (__v8si)__a;
+  return __b[__imm];
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm256_extract_epi16(__m256i a, int const imm)
+_mm256_extract_epi16(__m256i __a, int const __imm)
 {
-  __v16hi b = (__v16hi)a;
-  return b[imm];
+  __v16hi __b = (__v16hi)__a;
+  return __b[__imm];
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm256_extract_epi8(__m256i a, int const imm)
+_mm256_extract_epi8(__m256i __a, int const __imm)
 {
-  __v32qi b = (__v32qi)a;
-  return b[imm];
+  __v32qi __b = (__v32qi)__a;
+  return __b[__imm];
 }
 
 #ifdef __x86_64__
 static __inline long long  __attribute__((__always_inline__, __nodebug__))
-_mm256_extract_epi64(__m256i a, const int imm)
+_mm256_extract_epi64(__m256i __a, const int __imm)
 {
-  __v4di b = (__v4di)a;
-  return b[imm];
+  __v4di __b = (__v4di)__a;
+  return __b[__imm];
 }
 #endif
 
@@ -473,237 +475,237 @@
   (__m256i)__builtin_ia32_vinsertf128_si256((__v8si)__V1, (__v4si)__V2, (O)); })
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_insert_epi32(__m256i a, int b, int const imm)
+_mm256_insert_epi32(__m256i __a, int __b, int const __imm)
 {
-  __v8si c = (__v8si)a;
-  c[imm & 7] = b;
-  return (__m256i)c;
+  __v8si __c = (__v8si)__a;
+  __c[__imm & 7] = __b;
+  return (__m256i)__c;
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_insert_epi16(__m256i a, int b, int const imm)
+_mm256_insert_epi16(__m256i __a, int __b, int const __imm)
 {
-  __v16hi c = (__v16hi)a;
-  c[imm & 15] = b;
-  return (__m256i)c;
+  __v16hi __c = (__v16hi)__a;
+  __c[__imm & 15] = __b;
+  return (__m256i)__c;
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_insert_epi8(__m256i a, int b, int const imm)
+_mm256_insert_epi8(__m256i __a, int __b, int const __imm)
 {
-  __v32qi c = (__v32qi)a;
-  c[imm & 31] = b;
-  return (__m256i)c;
+  __v32qi __c = (__v32qi)__a;
+  __c[__imm & 31] = __b;
+  return (__m256i)__c;
 }
 
 #ifdef __x86_64__
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_insert_epi64(__m256i a, int b, int const imm)
+_mm256_insert_epi64(__m256i __a, int __b, int const __imm)
 {
-  __v4di c = (__v4di)a;
-  c[imm & 3] = b;
-  return (__m256i)c;
+  __v4di __c = (__v4di)__a;
+  __c[__imm & 3] = __b;
+  return (__m256i)__c;
 }
 #endif
 
 /* Conversion */
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_cvtepi32_pd(__m128i a)
+_mm256_cvtepi32_pd(__m128i __a)
 {
-  return (__m256d)__builtin_ia32_cvtdq2pd256((__v4si) a);
+  return (__m256d)__builtin_ia32_cvtdq2pd256((__v4si) __a);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_cvtepi32_ps(__m256i a)
+_mm256_cvtepi32_ps(__m256i __a)
 {
-  return (__m256)__builtin_ia32_cvtdq2ps256((__v8si) a);
+  return (__m256)__builtin_ia32_cvtdq2ps256((__v8si) __a);
 }
 
 static __inline __m128 __attribute__((__always_inline__, __nodebug__))
-_mm256_cvtpd_ps(__m256d a)
+_mm256_cvtpd_ps(__m256d __a)
 {
-  return (__m128)__builtin_ia32_cvtpd2ps256((__v4df) a);
+  return (__m128)__builtin_ia32_cvtpd2ps256((__v4df) __a);
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_cvtps_epi32(__m256 a)
+_mm256_cvtps_epi32(__m256 __a)
 {
-  return (__m256i)__builtin_ia32_cvtps2dq256((__v8sf) a);
+  return (__m256i)__builtin_ia32_cvtps2dq256((__v8sf) __a);
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_cvtps_pd(__m128 a)
+_mm256_cvtps_pd(__m128 __a)
 {
-  return (__m256d)__builtin_ia32_cvtps2pd256((__v4sf) a);
+  return (__m256d)__builtin_ia32_cvtps2pd256((__v4sf) __a);
 }
 
 static __inline __m128i __attribute__((__always_inline__, __nodebug__))
-_mm256_cvttpd_epi32(__m256d a)
+_mm256_cvttpd_epi32(__m256d __a)
 {
-  return (__m128i)__builtin_ia32_cvttpd2dq256((__v4df) a);
+  return (__m128i)__builtin_ia32_cvttpd2dq256((__v4df) __a);
 }
 
 static __inline __m128i __attribute__((__always_inline__, __nodebug__))
-_mm256_cvtpd_epi32(__m256d a)
+_mm256_cvtpd_epi32(__m256d __a)
 {
-  return (__m128i)__builtin_ia32_cvtpd2dq256((__v4df) a);
+  return (__m128i)__builtin_ia32_cvtpd2dq256((__v4df) __a);
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_cvttps_epi32(__m256 a)
+_mm256_cvttps_epi32(__m256 __a)
 {
-  return (__m256i)__builtin_ia32_cvttps2dq256((__v8sf) a);
+  return (__m256i)__builtin_ia32_cvttps2dq256((__v8sf) __a);
 }
 
 /* Vector replicate */
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_movehdup_ps(__m256 a)
+_mm256_movehdup_ps(__m256 __a)
 {
-  return __builtin_shufflevector(a, a, 1, 1, 3, 3, 5, 5, 7, 7);
+  return __builtin_shufflevector(__a, __a, 1, 1, 3, 3, 5, 5, 7, 7);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_moveldup_ps(__m256 a)
+_mm256_moveldup_ps(__m256 __a)
 {
-  return __builtin_shufflevector(a, a, 0, 0, 2, 2, 4, 4, 6, 6);
+  return __builtin_shufflevector(__a, __a, 0, 0, 2, 2, 4, 4, 6, 6);
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_movedup_pd(__m256d a)
+_mm256_movedup_pd(__m256d __a)
 {
-  return __builtin_shufflevector(a, a, 0, 0, 2, 2);
+  return __builtin_shufflevector(__a, __a, 0, 0, 2, 2);
 }
 
 /* Unpack and Interleave */
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_unpackhi_pd(__m256d a, __m256d b)
+_mm256_unpackhi_pd(__m256d __a, __m256d __b)
 {
-  return __builtin_shufflevector(a, b, 1, 5, 1+2, 5+2);
+  return __builtin_shufflevector(__a, __b, 1, 5, 1+2, 5+2);
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_unpacklo_pd(__m256d a, __m256d b)
+_mm256_unpacklo_pd(__m256d __a, __m256d __b)
 {
-  return __builtin_shufflevector(a, b, 0, 4, 0+2, 4+2);
+  return __builtin_shufflevector(__a, __b, 0, 4, 0+2, 4+2);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_unpackhi_ps(__m256 a, __m256 b)
+_mm256_unpackhi_ps(__m256 __a, __m256 __b)
 {
-  return __builtin_shufflevector(a, b, 2, 10, 2+1, 10+1, 6, 14, 6+1, 14+1);
+  return __builtin_shufflevector(__a, __b, 2, 10, 2+1, 10+1, 6, 14, 6+1, 14+1);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_unpacklo_ps(__m256 a, __m256 b)
+_mm256_unpacklo_ps(__m256 __a, __m256 __b)
 {
-  return __builtin_shufflevector(a, b, 0, 8, 0+1, 8+1, 4, 12, 4+1, 12+1);
+  return __builtin_shufflevector(__a, __b, 0, 8, 0+1, 8+1, 4, 12, 4+1, 12+1);
 }
 
 /* Bit Test */
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm_testz_pd(__m128d a, __m128d b)
+_mm_testz_pd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_vtestzpd((__v2df)a, (__v2df)b);
+  return __builtin_ia32_vtestzpd((__v2df)__a, (__v2df)__b);
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm_testc_pd(__m128d a, __m128d b)
+_mm_testc_pd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_vtestcpd((__v2df)a, (__v2df)b);
+  return __builtin_ia32_vtestcpd((__v2df)__a, (__v2df)__b);
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm_testnzc_pd(__m128d a, __m128d b)
+_mm_testnzc_pd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_vtestnzcpd((__v2df)a, (__v2df)b);
+  return __builtin_ia32_vtestnzcpd((__v2df)__a, (__v2df)__b);
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm_testz_ps(__m128 a, __m128 b)
+_mm_testz_ps(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_vtestzps((__v4sf)a, (__v4sf)b);
+  return __builtin_ia32_vtestzps((__v4sf)__a, (__v4sf)__b);
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm_testc_ps(__m128 a, __m128 b)
+_mm_testc_ps(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_vtestcps((__v4sf)a, (__v4sf)b);
+  return __builtin_ia32_vtestcps((__v4sf)__a, (__v4sf)__b);
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm_testnzc_ps(__m128 a, __m128 b)
+_mm_testnzc_ps(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_vtestnzcps((__v4sf)a, (__v4sf)b);
+  return __builtin_ia32_vtestnzcps((__v4sf)__a, (__v4sf)__b);
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm256_testz_pd(__m256d a, __m256d b)
+_mm256_testz_pd(__m256d __a, __m256d __b)
 {
-  return __builtin_ia32_vtestzpd256((__v4df)a, (__v4df)b);
+  return __builtin_ia32_vtestzpd256((__v4df)__a, (__v4df)__b);
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm256_testc_pd(__m256d a, __m256d b)
+_mm256_testc_pd(__m256d __a, __m256d __b)
 {
-  return __builtin_ia32_vtestcpd256((__v4df)a, (__v4df)b);
+  return __builtin_ia32_vtestcpd256((__v4df)__a, (__v4df)__b);
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm256_testnzc_pd(__m256d a, __m256d b)
+_mm256_testnzc_pd(__m256d __a, __m256d __b)
 {
-  return __builtin_ia32_vtestnzcpd256((__v4df)a, (__v4df)b);
+  return __builtin_ia32_vtestnzcpd256((__v4df)__a, (__v4df)__b);
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm256_testz_ps(__m256 a, __m256 b)
+_mm256_testz_ps(__m256 __a, __m256 __b)
 {
-  return __builtin_ia32_vtestzps256((__v8sf)a, (__v8sf)b);
+  return __builtin_ia32_vtestzps256((__v8sf)__a, (__v8sf)__b);
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm256_testc_ps(__m256 a, __m256 b)
+_mm256_testc_ps(__m256 __a, __m256 __b)
 {
-  return __builtin_ia32_vtestcps256((__v8sf)a, (__v8sf)b);
+  return __builtin_ia32_vtestcps256((__v8sf)__a, (__v8sf)__b);
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm256_testnzc_ps(__m256 a, __m256 b)
+_mm256_testnzc_ps(__m256 __a, __m256 __b)
 {
-  return __builtin_ia32_vtestnzcps256((__v8sf)a, (__v8sf)b);
+  return __builtin_ia32_vtestnzcps256((__v8sf)__a, (__v8sf)__b);
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm256_testz_si256(__m256i a, __m256i b)
+_mm256_testz_si256(__m256i __a, __m256i __b)
 {
-  return __builtin_ia32_ptestz256((__v4di)a, (__v4di)b);
+  return __builtin_ia32_ptestz256((__v4di)__a, (__v4di)__b);
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm256_testc_si256(__m256i a, __m256i b)
+_mm256_testc_si256(__m256i __a, __m256i __b)
 {
-  return __builtin_ia32_ptestc256((__v4di)a, (__v4di)b);
+  return __builtin_ia32_ptestc256((__v4di)__a, (__v4di)__b);
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm256_testnzc_si256(__m256i a, __m256i b)
+_mm256_testnzc_si256(__m256i __a, __m256i __b)
 {
-  return __builtin_ia32_ptestnzc256((__v4di)a, (__v4di)b);
+  return __builtin_ia32_ptestnzc256((__v4di)__a, (__v4di)__b);
 }
 
 /* Vector extract sign mask */
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm256_movemask_pd(__m256d a)
+_mm256_movemask_pd(__m256d __a)
 {
-  return __builtin_ia32_movmskpd256((__v4df)a);
+  return __builtin_ia32_movmskpd256((__v4df)__a);
 }
 
 static __inline int __attribute__((__always_inline__, __nodebug__))
-_mm256_movemask_ps(__m256 a)
+_mm256_movemask_ps(__m256 __a)
 {
-  return __builtin_ia32_movmskps256((__v8sf)a);
+  return __builtin_ia32_movmskps256((__v8sf)__a);
 }
 
-/* Vector zero */
+/* Vector __zero */
 static __inline void __attribute__((__always_inline__, __nodebug__))
 _mm256_zeroall(void)
 {
@@ -718,341 +720,344 @@
 
 /* Vector load with broadcast */
 static __inline __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_broadcast_ss(float const *a)
+_mm_broadcast_ss(float const *__a)
 {
-  return (__m128)__builtin_ia32_vbroadcastss(a);
+  return (__m128)__builtin_ia32_vbroadcastss(__a);
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_broadcast_sd(double const *a)
+_mm256_broadcast_sd(double const *__a)
 {
-  return (__m256d)__builtin_ia32_vbroadcastsd256(a);
+  return (__m256d)__builtin_ia32_vbroadcastsd256(__a);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_broadcast_ss(float const *a)
+_mm256_broadcast_ss(float const *__a)
 {
-  return (__m256)__builtin_ia32_vbroadcastss256(a);
+  return (__m256)__builtin_ia32_vbroadcastss256(__a);
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_broadcast_pd(__m128d const *a)
+_mm256_broadcast_pd(__m128d const *__a)
 {
-  return (__m256d)__builtin_ia32_vbroadcastf128_pd256(a);
+  return (__m256d)__builtin_ia32_vbroadcastf128_pd256(__a);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_broadcast_ps(__m128 const *a)
+_mm256_broadcast_ps(__m128 const *__a)
 {
-  return (__m256)__builtin_ia32_vbroadcastf128_ps256(a);
+  return (__m256)__builtin_ia32_vbroadcastf128_ps256(__a);
 }
 
 /* SIMD load ops */
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_load_pd(double const *p)
+_mm256_load_pd(double const *__p)
 {
-  return *(__m256d *)p;
+  return *(__m256d *)__p;
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_load_ps(float const *p)
+_mm256_load_ps(float const *__p)
 {
-  return *(__m256 *)p;
+  return *(__m256 *)__p;
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_loadu_pd(double const *p)
+_mm256_loadu_pd(double const *__p)
 {
   struct __loadu_pd {
-    __m256d v;
+    __m256d __v;
   } __attribute__((packed, may_alias));
-  return ((struct __loadu_pd*)p)->v;
+  return ((struct __loadu_pd*)__p)->__v;
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_loadu_ps(float const *p)
+_mm256_loadu_ps(float const *__p)
 {
   struct __loadu_ps {
-    __m256 v;
+    __m256 __v;
   } __attribute__((packed, may_alias));
-  return ((struct __loadu_ps*)p)->v;
+  return ((struct __loadu_ps*)__p)->__v;
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_load_si256(__m256i const *p)
+_mm256_load_si256(__m256i const *__p)
 {
-  return *p;
+  return *__p;
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_loadu_si256(__m256i const *p)
+_mm256_loadu_si256(__m256i const *__p)
 {
   struct __loadu_si256 {
-    __m256i v;
+    __m256i __v;
   } __attribute__((packed, may_alias));
-  return ((struct __loadu_si256*)p)->v;
+  return ((struct __loadu_si256*)__p)->__v;
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_lddqu_si256(__m256i const *p)
+_mm256_lddqu_si256(__m256i const *__p)
 {
-  return (__m256i)__builtin_ia32_lddqu256((char const *)p);
+  return (__m256i)__builtin_ia32_lddqu256((char const *)__p);
 }
 
 /* SIMD store ops */
 static __inline void __attribute__((__always_inline__, __nodebug__))
-_mm256_store_pd(double *p, __m256d a)
+_mm256_store_pd(double *__p, __m256d __a)
 {
-  *(__m256d *)p = a;
+  *(__m256d *)__p = __a;
 }
 
 static __inline void __attribute__((__always_inline__, __nodebug__))
-_mm256_store_ps(float *p, __m256 a)
+_mm256_store_ps(float *__p, __m256 __a)
 {
-  *(__m256 *)p = a;
+  *(__m256 *)__p = __a;
 }
 
 static __inline void __attribute__((__always_inline__, __nodebug__))
-_mm256_storeu_pd(double *p, __m256d a)
+_mm256_storeu_pd(double *__p, __m256d __a)
 {
-  __builtin_ia32_storeupd256(p, (__v4df)a);
+  __builtin_ia32_storeupd256(__p, (__v4df)__a);
 }
 
 static __inline void __attribute__((__always_inline__, __nodebug__))
-_mm256_storeu_ps(float *p, __m256 a)
+_mm256_storeu_ps(float *__p, __m256 __a)
 {
-  __builtin_ia32_storeups256(p, (__v8sf)a);
+  __builtin_ia32_storeups256(__p, (__v8sf)__a);
 }
 
 static __inline void __attribute__((__always_inline__, __nodebug__))
-_mm256_store_si256(__m256i *p, __m256i a)
+_mm256_store_si256(__m256i *__p, __m256i __a)
 {
-  *p = a;
+  *__p = __a;
 }
 
 static __inline void __attribute__((__always_inline__, __nodebug__))
-_mm256_storeu_si256(__m256i *p, __m256i a)
+_mm256_storeu_si256(__m256i *__p, __m256i __a)
 {
-  __builtin_ia32_storedqu256((char *)p, (__v32qi)a);
+  __builtin_ia32_storedqu256((char *)__p, (__v32qi)__a);
 }
 
 /* Conditional load ops */
 static __inline __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_maskload_pd(double const *p, __m128d m)
+_mm_maskload_pd(double const *__p, __m128d __m)
 {
-  return (__m128d)__builtin_ia32_maskloadpd((const __v2df *)p, (__v2df)m);
+  return (__m128d)__builtin_ia32_maskloadpd((const __v2df *)__p, (__v2df)__m);
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_maskload_pd(double const *p, __m256d m)
+_mm256_maskload_pd(double const *__p, __m256d __m)
 {
-  return (__m256d)__builtin_ia32_maskloadpd256((const __v4df *)p, (__v4df)m);
+  return (__m256d)__builtin_ia32_maskloadpd256((const __v4df *)__p,
+                                               (__v4df)__m);
 }
 
 static __inline __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_maskload_ps(float const *p, __m128 m)
+_mm_maskload_ps(float const *__p, __m128 __m)
 {
-  return (__m128)__builtin_ia32_maskloadps((const __v4sf *)p, (__v4sf)m);
+  return (__m128)__builtin_ia32_maskloadps((const __v4sf *)__p, (__v4sf)__m);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_maskload_ps(float const *p, __m256 m)
+_mm256_maskload_ps(float const *__p, __m256 __m)
 {
-  return (__m256)__builtin_ia32_maskloadps256((const __v8sf *)p, (__v8sf)m);
+  return (__m256)__builtin_ia32_maskloadps256((const __v8sf *)__p, (__v8sf)__m);
 }
 
 /* Conditional store ops */
 static __inline void __attribute__((__always_inline__, __nodebug__))
-_mm256_maskstore_ps(float *p, __m256 m, __m256 a)
+_mm256_maskstore_ps(float *__p, __m256 __m, __m256 __a)
 {
-  __builtin_ia32_maskstoreps256((__v8sf *)p, (__v8sf)m, (__v8sf)a);
+  __builtin_ia32_maskstoreps256((__v8sf *)__p, (__v8sf)__m, (__v8sf)__a);
 }
 
 static __inline void __attribute__((__always_inline__, __nodebug__))
-_mm_maskstore_pd(double *p, __m128d m, __m128d a)
+_mm_maskstore_pd(double *__p, __m128d __m, __m128d __a)
 {
-  __builtin_ia32_maskstorepd((__v2df *)p, (__v2df)m, (__v2df)a);
+  __builtin_ia32_maskstorepd((__v2df *)__p, (__v2df)__m, (__v2df)__a);
 }
 
 static __inline void __attribute__((__always_inline__, __nodebug__))
-_mm256_maskstore_pd(double *p, __m256d m, __m256d a)
+_mm256_maskstore_pd(double *__p, __m256d __m, __m256d __a)
 {
-  __builtin_ia32_maskstorepd256((__v4df *)p, (__v4df)m, (__v4df)a);
+  __builtin_ia32_maskstorepd256((__v4df *)__p, (__v4df)__m, (__v4df)__a);
 }
 
 static __inline void __attribute__((__always_inline__, __nodebug__))
-_mm_maskstore_ps(float *p, __m128 m, __m128 a)
+_mm_maskstore_ps(float *__p, __m128 __m, __m128 __a)
 {
-  __builtin_ia32_maskstoreps((__v4sf *)p, (__v4sf)m, (__v4sf)a);
+  __builtin_ia32_maskstoreps((__v4sf *)__p, (__v4sf)__m, (__v4sf)__a);
 }
 
 /* Cacheability support ops */
 static __inline void __attribute__((__always_inline__, __nodebug__))
-_mm256_stream_si256(__m256i *a, __m256i b)
+_mm256_stream_si256(__m256i *__a, __m256i __b)
 {
-  __builtin_ia32_movntdq256((__v4di *)a, (__v4di)b);
+  __builtin_ia32_movntdq256((__v4di *)__a, (__v4di)__b);
 }
 
 static __inline void __attribute__((__always_inline__, __nodebug__))
-_mm256_stream_pd(double *a, __m256d b)
+_mm256_stream_pd(double *__a, __m256d __b)
 {
-  __builtin_ia32_movntpd256(a, (__v4df)b);
+  __builtin_ia32_movntpd256(__a, (__v4df)__b);
 }
 
 static __inline void __attribute__((__always_inline__, __nodebug__))
-_mm256_stream_ps(float *p, __m256 a)
+_mm256_stream_ps(float *__p, __m256 __a)
 {
-  __builtin_ia32_movntps256(p, (__v8sf)a);
+  __builtin_ia32_movntps256(__p, (__v8sf)__a);
 }
 
 /* Create vectors */
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_set_pd(double a, double b, double c, double d)
+_mm256_set_pd(double __a, double __b, double __c, double __d)
 {
-  return (__m256d){ d, c, b, a };
+  return (__m256d){ __d, __c, __b, __a };
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_set_ps(float a, float b, float c, float d,
-	            float e, float f, float g, float h)
+_mm256_set_ps(float __a, float __b, float __c, float __d,
+	            float __e, float __f, float __g, float __h)
 {
-  return (__m256){ h, g, f, e, d, c, b, a };
+  return (__m256){ __h, __g, __f, __e, __d, __c, __b, __a };
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_set_epi32(int i0, int i1, int i2, int i3,
-		             int i4, int i5, int i6, int i7)
+_mm256_set_epi32(int __i0, int __i1, int __i2, int __i3,
+		             int __i4, int __i5, int __i6, int __i7)
 {
-  return (__m256i)(__v8si){ i7, i6, i5, i4, i3, i2, i1, i0 };
+  return (__m256i)(__v8si){ __i7, __i6, __i5, __i4, __i3, __i2, __i1, __i0 };
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_set_epi16(short w15, short w14, short w13, short w12,
-		             short w11, short w10, short w09, short w08,
-		             short w07, short w06, short w05, short w04,
-		             short w03, short w02, short w01, short w00)
+_mm256_set_epi16(short __w15, short __w14, short __w13, short __w12,
+		             short __w11, short __w10, short __w09, short __w08,
+		             short __w07, short __w06, short __w05, short __w04,
+		             short __w03, short __w02, short __w01, short __w00)
 {
-  return (__m256i)(__v16hi){ w00, w01, w02, w03, w04, w05, w06, w07,
-                             w08, w09, w10, w11, w12, w13, w14, w15 };
+  return (__m256i)(__v16hi){ __w00, __w01, __w02, __w03, __w04, __w05, __w06,
+    __w07, __w08, __w09, __w10, __w11, __w12, __w13, __w14, __w15 };
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_set_epi8(char b31, char b30, char b29, char b28,
-		            char b27, char b26, char b25, char b24,
-		            char b23, char b22, char b21, char b20,
-		            char b19, char b18, char b17, char b16,
-		            char b15, char b14, char b13, char b12,
-		            char b11, char b10, char b09, char b08,
-		            char b07, char b06, char b05, char b04,
-		            char b03, char b02, char b01, char b00)
+_mm256_set_epi8(char __b31, char __b30, char __b29, char __b28,
+		            char __b27, char __b26, char __b25, char __b24,
+		            char __b23, char __b22, char __b21, char __b20,
+		            char __b19, char __b18, char __b17, char __b16,
+		            char __b15, char __b14, char __b13, char __b12,
+		            char __b11, char __b10, char __b09, char __b08,
+		            char __b07, char __b06, char __b05, char __b04,
+		            char __b03, char __b02, char __b01, char __b00)
 {
   return (__m256i)(__v32qi){
-    b00, b01, b02, b03, b04, b05, b06, b07,
-    b08, b09, b10, b11, b12, b13, b14, b15,
-    b16, b17, b18, b19, b20, b21, b22, b23,
-    b24, b25, b26, b27, b28, b29, b30, b31
+    __b00, __b01, __b02, __b03, __b04, __b05, __b06, __b07,
+    __b08, __b09, __b10, __b11, __b12, __b13, __b14, __b15,
+    __b16, __b17, __b18, __b19, __b20, __b21, __b22, __b23,
+    __b24, __b25, __b26, __b27, __b28, __b29, __b30, __b31
   };
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_set_epi64x(long long a, long long b, long long c, long long d)
+_mm256_set_epi64x(long long __a, long long __b, long long __c, long long __d)
 {
-  return (__m256i)(__v4di){ d, c, b, a };
+  return (__m256i)(__v4di){ __d, __c, __b, __a };
 }
 
 /* Create vectors with elements in reverse order */
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_setr_pd(double a, double b, double c, double d)
+_mm256_setr_pd(double __a, double __b, double __c, double __d)
 {
-  return (__m256d){ a, b, c, d };
+  return (__m256d){ __a, __b, __c, __d };
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_setr_ps(float a, float b, float c, float d,
-		           float e, float f, float g, float h)
+_mm256_setr_ps(float __a, float __b, float __c, float __d,
+		           float __e, float __f, float __g, float __h)
 {
-  return (__m256){ a, b, c, d, e, f, g, h };
+  return (__m256){ __a, __b, __c, __d, __e, __f, __g, __h };
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_setr_epi32(int i0, int i1, int i2, int i3,
-		              int i4, int i5, int i6, int i7)
+_mm256_setr_epi32(int __i0, int __i1, int __i2, int __i3,
+		              int __i4, int __i5, int __i6, int __i7)
 {
-  return (__m256i)(__v8si){ i0, i1, i2, i3, i4, i5, i6, i7 };
+  return (__m256i)(__v8si){ __i0, __i1, __i2, __i3, __i4, __i5, __i6, __i7 };
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_setr_epi16(short w15, short w14, short w13, short w12,
-		   short w11, short w10, short w09, short w08,
-		   short w07, short w06, short w05, short w04,
-		   short w03, short w02, short w01, short w00)
+_mm256_setr_epi16(short __w15, short __w14, short __w13, short __w12,
+		   short __w11, short __w10, short __w09, short __w08,
+		   short __w07, short __w06, short __w05, short __w04,
+		   short __w03, short __w02, short __w01, short __w00)
 {
-  return (__m256i)(__v16hi){ w15, w14, w13, w12, w11, w10, w09, w08,
-			                       w07, w06, w05, w04, w03, w02, w01, w00 };
+  return (__m256i)(__v16hi){ __w15, __w14, __w13, __w12, __w11, __w10, __w09,
+    __w08, __w07, __w06, __w05, __w04, __w03, __w02, __w01, __w00 };
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_setr_epi8(char b31, char b30, char b29, char b28,
-		             char b27, char b26, char b25, char b24,
-		             char b23, char b22, char b21, char b20,
-		             char b19, char b18, char b17, char b16,
-		             char b15, char b14, char b13, char b12,
-		             char b11, char b10, char b09, char b08,
-		             char b07, char b06, char b05, char b04,
-		             char b03, char b02, char b01, char b00)
+_mm256_setr_epi8(char __b31, char __b30, char __b29, char __b28,
+		             char __b27, char __b26, char __b25, char __b24,
+		             char __b23, char __b22, char __b21, char __b20,
+		             char __b19, char __b18, char __b17, char __b16,
+		             char __b15, char __b14, char __b13, char __b12,
+		             char __b11, char __b10, char __b09, char __b08,
+		             char __b07, char __b06, char __b05, char __b04,
+		             char __b03, char __b02, char __b01, char __b00)
 {
   return (__m256i)(__v32qi){
-    b31, b30, b29, b28, b27, b26, b25, b24,
-		b23, b22, b21, b20, b19, b18, b17, b16,
-		b15, b14, b13, b12, b11, b10, b09, b08,
-		b07, b06, b05, b04, b03, b02, b01, b00 };
+    __b31, __b30, __b29, __b28, __b27, __b26, __b25, __b24,
+		__b23, __b22, __b21, __b20, __b19, __b18, __b17, __b16,
+		__b15, __b14, __b13, __b12, __b11, __b10, __b09, __b08,
+		__b07, __b06, __b05, __b04, __b03, __b02, __b01, __b00 };
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_setr_epi64x(long long a, long long b, long long c, long long d)
+_mm256_setr_epi64x(long long __a, long long __b, long long __c, long long __d)
 {
-  return (__m256i)(__v4di){ a, b, c, d };
+  return (__m256i)(__v4di){ __a, __b, __c, __d };
 }
 
 /* Create vectors with repeated elements */
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_set1_pd(double w)
+_mm256_set1_pd(double __w)
 {
-  return (__m256d){ w, w, w, w };
+  return (__m256d){ __w, __w, __w, __w };
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_set1_ps(float w)
+_mm256_set1_ps(float __w)
 {
-  return (__m256){ w, w, w, w, w, w, w, w };
+  return (__m256){ __w, __w, __w, __w, __w, __w, __w, __w };
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_set1_epi32(int i)
+_mm256_set1_epi32(int __i)
 {
-  return (__m256i)(__v8si){ i, i, i, i, i, i, i, i };
+  return (__m256i)(__v8si){ __i, __i, __i, __i, __i, __i, __i, __i };
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_set1_epi16(short w)
+_mm256_set1_epi16(short __w)
 {
-  return (__m256i)(__v16hi){ w, w, w, w, w, w, w, w, w, w, w, w, w, w, w, w };
+  return (__m256i)(__v16hi){ __w, __w, __w, __w, __w, __w, __w, __w, __w, __w,
+    __w, __w, __w, __w, __w, __w };
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_set1_epi8(char b)
+_mm256_set1_epi8(char __b)
 {
-  return (__m256i)(__v32qi){ b, b, b, b, b, b, b, b, b, b, b, b, b, b, b, b,
-                             b, b, b, b, b, b, b, b, b, b, b, b, b, b, b, b };
+  return (__m256i)(__v32qi){ __b, __b, __b, __b, __b, __b, __b, __b, __b, __b,
+    __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b,
+    __b, __b, __b, __b, __b, __b, __b };
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_set1_epi64x(long long q)
+_mm256_set1_epi64x(long long __q)
 {
-  return (__m256i)(__v4di){ q, q, q, q };
+  return (__m256i)(__v4di){ __q, __q, __q, __q };
 }
 
-/* Create zeroed vectors */
+/* Create __zeroed vectors */
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
 _mm256_setzero_pd(void)
 {
@@ -1073,143 +1078,145 @@
 
 /* Cast between vector types */
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_castpd_ps(__m256d in)
+_mm256_castpd_ps(__m256d __in)
 {
-  return (__m256)in;
+  return (__m256)__in;
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_castpd_si256(__m256d in)
+_mm256_castpd_si256(__m256d __in)
 {
-  return (__m256i)in;
+  return (__m256i)__in;
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_castps_pd(__m256 in)
+_mm256_castps_pd(__m256 __in)
 {
-  return (__m256d)in;
+  return (__m256d)__in;
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_castps_si256(__m256 in)
+_mm256_castps_si256(__m256 __in)
 {
-  return (__m256i)in;
+  return (__m256i)__in;
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_castsi256_ps(__m256i in)
+_mm256_castsi256_ps(__m256i __in)
 {
-  return (__m256)in;
+  return (__m256)__in;
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_castsi256_pd(__m256i in)
+_mm256_castsi256_pd(__m256i __in)
 {
-  return (__m256d)in;
+  return (__m256d)__in;
 }
 
 static __inline __m128d __attribute__((__always_inline__, __nodebug__))
-_mm256_castpd256_pd128(__m256d in)
+_mm256_castpd256_pd128(__m256d __in)
 {
-  return __builtin_shufflevector(in, in, 0, 1);
+  return __builtin_shufflevector(__in, __in, 0, 1);
 }
 
 static __inline __m128 __attribute__((__always_inline__, __nodebug__))
-_mm256_castps256_ps128(__m256 in)
+_mm256_castps256_ps128(__m256 __in)
 {
-  return __builtin_shufflevector(in, in, 0, 1, 2, 3);
+  return __builtin_shufflevector(__in, __in, 0, 1, 2, 3);
 }
 
 static __inline __m128i __attribute__((__always_inline__, __nodebug__))
-_mm256_castsi256_si128(__m256i in)
+_mm256_castsi256_si128(__m256i __in)
 {
-  return __builtin_shufflevector(in, in, 0, 1);
+  return __builtin_shufflevector(__in, __in, 0, 1);
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_castpd128_pd256(__m128d in)
+_mm256_castpd128_pd256(__m128d __in)
 {
-  __m128d zero = _mm_setzero_pd();
-  return __builtin_shufflevector(in, zero, 0, 1, 2, 2);
+  __m128d __zero = _mm_setzero_pd();
+  return __builtin_shufflevector(__in, __zero, 0, 1, 2, 2);
 }
 
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_castps128_ps256(__m128 in)
+_mm256_castps128_ps256(__m128 __in)
 {
-  __m128 zero = _mm_setzero_ps();
-  return __builtin_shufflevector(in, zero, 0, 1, 2, 3, 4, 4, 4, 4);
+  __m128 __zero = _mm_setzero_ps();
+  return __builtin_shufflevector(__in, __zero, 0, 1, 2, 3, 4, 4, 4, 4);
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_castsi128_si256(__m128i in)
+_mm256_castsi128_si256(__m128i __in)
 {
-  __m128i zero = _mm_setzero_si128();
-  return __builtin_shufflevector(in, zero, 0, 1, 2, 2);
+  __m128i __zero = _mm_setzero_si128();
+  return __builtin_shufflevector(__in, __zero, 0, 1, 2, 2);
 }
 
 /* SIMD load ops (unaligned) */
 static __inline __m256 __attribute__((__always_inline__, __nodebug__))
-_mm256_loadu2_m128(float const *addr_hi, float const *addr_lo)
+_mm256_loadu2_m128(float const *__addr_hi, float const *__addr_lo)
 {
   struct __loadu_ps {
-    __m128 v;
+    __m128 __v;
   } __attribute__((__packed__, __may_alias__));
 
-  __m256 v256 = _mm256_castps128_ps256(((struct __loadu_ps*)addr_lo)->v);
-  return _mm256_insertf128_ps(v256, ((struct __loadu_ps*)addr_hi)->v, 1);
+  __m256 __v256 = _mm256_castps128_ps256(((struct __loadu_ps*)__addr_lo)->__v);
+  return _mm256_insertf128_ps(__v256, ((struct __loadu_ps*)__addr_hi)->__v, 1);
 }
 
 static __inline __m256d __attribute__((__always_inline__, __nodebug__))
-_mm256_loadu2_m128d(double const *addr_hi, double const *addr_lo)
+_mm256_loadu2_m128d(double const *__addr_hi, double const *__addr_lo)
 {
   struct __loadu_pd {
-    __m128d v;
+    __m128d __v;
   } __attribute__((__packed__, __may_alias__));
   
-  __m256d v256 = _mm256_castpd128_pd256(((struct __loadu_pd*)addr_lo)->v);
-  return _mm256_insertf128_pd(v256, ((struct __loadu_pd*)addr_hi)->v, 1);
+  __m256d __v256 = _mm256_castpd128_pd256(((struct __loadu_pd*)__addr_lo)->__v);
+  return _mm256_insertf128_pd(__v256, ((struct __loadu_pd*)__addr_hi)->__v, 1);
 }
 
 static __inline __m256i __attribute__((__always_inline__, __nodebug__))
-_mm256_loadu2_m128i(__m128i const *addr_hi, __m128i const *addr_lo)
+_mm256_loadu2_m128i(__m128i const *__addr_hi, __m128i const *__addr_lo)
 {
   struct __loadu_si128 {
-    __m128i v;
+    __m128i __v;
   } __attribute__((packed, may_alias));
-  __m256i v256 = _mm256_castsi128_si256(((struct __loadu_si128*)addr_lo)->v);
-  return _mm256_insertf128_si256(v256, ((struct __loadu_si128*)addr_hi)->v, 1);
+  __m256i __v256 = _mm256_castsi128_si256(
+    ((struct __loadu_si128*)__addr_lo)->__v);
+  return _mm256_insertf128_si256(__v256,
+                                 ((struct __loadu_si128*)__addr_hi)->__v, 1);
 }
 
 /* SIMD store ops (unaligned) */
 static __inline void __attribute__((__always_inline__, __nodebug__))
-_mm256_storeu2_m128(float *addr_hi, float *addr_lo, __m256 a)
+_mm256_storeu2_m128(float *__addr_hi, float *__addr_lo, __m256 __a)
 {
-  __m128 v128;
+  __m128 __v128;
 
-  v128 = _mm256_castps256_ps128(a);
-  __builtin_ia32_storeups(addr_lo, v128);
-  v128 = _mm256_extractf128_ps(a, 1);
-  __builtin_ia32_storeups(addr_hi, v128);
+  __v128 = _mm256_castps256_ps128(__a);
+  __builtin_ia32_storeups(__addr_lo, __v128);
+  __v128 = _mm256_extractf128_ps(__a, 1);
+  __builtin_ia32_storeups(__addr_hi, __v128);
 }
 
 static __inline void __attribute__((__always_inline__, __nodebug__))
-_mm256_storeu2_m128d(double *addr_hi, double *addr_lo, __m256d a)
+_mm256_storeu2_m128d(double *__addr_hi, double *__addr_lo, __m256d __a)
 {
-  __m128d v128;
+  __m128d __v128;
 
-  v128 = _mm256_castpd256_pd128(a);
-  __builtin_ia32_storeupd(addr_lo, v128);
-  v128 = _mm256_extractf128_pd(a, 1);
-  __builtin_ia32_storeupd(addr_hi, v128);
+  __v128 = _mm256_castpd256_pd128(__a);
+  __builtin_ia32_storeupd(__addr_lo, __v128);
+  __v128 = _mm256_extractf128_pd(__a, 1);
+  __builtin_ia32_storeupd(__addr_hi, __v128);
 }
 
 static __inline void __attribute__((__always_inline__, __nodebug__))
-_mm256_storeu2_m128i(__m128i *addr_hi, __m128i *addr_lo, __m256i a)
+_mm256_storeu2_m128i(__m128i *__addr_hi, __m128i *__addr_lo, __m256i __a)
 {
-  __m128i v128;
+  __m128i __v128;
 
-  v128 = _mm256_castsi256_si128(a);
-  __builtin_ia32_storedqu((char *)addr_lo, (__v16qi)v128);
-  v128 = _mm256_extractf128_si256(a, 1);
-  __builtin_ia32_storedqu((char *)addr_hi, (__v16qi)v128);
+  __v128 = _mm256_castsi256_si128(__a);
+  __builtin_ia32_storedqu((char *)__addr_lo, (__v16qi)__v128);
+  __v128 = _mm256_extractf128_si256(__a, 1);
+  __builtin_ia32_storedqu((char *)__addr_hi, (__v16qi)__v128);
 }
diff --git a/renderscript/clang-include/bmi2intrin.h b/renderscript/clang-include/bmi2intrin.h
index c60b0c4..a05cfad 100644
--- a/renderscript/clang-include/bmi2intrin.h
+++ b/renderscript/clang-include/bmi2intrin.h
@@ -70,6 +70,25 @@
   return __builtin_ia32_pext_di(__X, __Y);
 }
 
+static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__))
+_mulx_u64 (unsigned long long __X, unsigned long long __Y,
+	   unsigned long long *__P)
+{
+  unsigned __int128 __res = (unsigned __int128) __X * __Y;
+  *__P = (unsigned long long) (__res >> 64);
+  return (unsigned long long) __res;
+}
+
+#else /* !__x86_64__ */
+
+static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__))
+_mulx_u32 (unsigned int __X, unsigned int __Y, unsigned int *__P)
+{
+  unsigned long long __res = (unsigned long long) __X * __Y;
+  *__P = (unsigned int) (__res >> 32);
+  return (unsigned int) __res;
+}
+
 #endif /* !__x86_64__  */
 
 #endif /* __BMI2INTRIN_H */
diff --git a/renderscript/clang-include/cpuid.h b/renderscript/clang-include/cpuid.h
index 05c293f..6d7d61d 100644
--- a/renderscript/clang-include/cpuid.h
+++ b/renderscript/clang-include/cpuid.h
@@ -25,9 +25,10 @@
 #error this header is for x86 only
 #endif
 
-static inline int __get_cpuid (unsigned int level, unsigned int *eax,
-                               unsigned int *ebx, unsigned int *ecx,
-                               unsigned int *edx) {
-    asm("cpuid" : "=a"(*eax), "=b" (*ebx), "=c"(*ecx), "=d"(*edx) : "0"(level));
+static inline int __get_cpuid (unsigned int __level, unsigned int *__eax,
+                               unsigned int *__ebx, unsigned int *__ecx,
+                               unsigned int *__edx) {
+    __asm("cpuid" : "=a"(*__eax), "=b" (*__ebx), "=c"(*__ecx), "=d"(*__edx)
+                  : "0"(__level));
     return 1;
 }
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 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 @@
 }
 
 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 @@
   (__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 @@
   (__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 @@
 }
 
 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 @@
 }
 
 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 @@
 }
 
 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 @@
                                    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 @@
   __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__))
diff --git a/renderscript/clang-include/f16cintrin.h b/renderscript/clang-include/f16cintrin.h
new file mode 100644
index 0000000..a6d7812
--- /dev/null
+++ b/renderscript/clang-include/f16cintrin.h
@@ -0,0 +1,58 @@
+/*===---- f16cintrin.h - F16C intrinsics ---------------------------------===
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining __a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined __X86INTRIN_H && !defined __IMMINTRIN_H
+#error "Never use <f16cintrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __F16C__
+# error "F16C instruction is not enabled"
+#endif /* __F16C__ */
+
+#ifndef __F16CINTRIN_H
+#define __F16CINTRIN_H
+
+typedef float __v8sf __attribute__ ((__vector_size__ (32)));
+typedef float __m256 __attribute__ ((__vector_size__ (32)));
+
+#define _mm_cvtps_ph(a, imm) __extension__ ({ \
+  __m128 __a = (a); \
+ (__m128i)__builtin_ia32_vcvtps2ph((__v4sf)__a, (imm)); })
+
+#define _mm256_cvtps_ph(a, imm) __extension__ ({ \
+  __m256 __a = (a); \
+ (__m128i)__builtin_ia32_vcvtps2ph256((__v8sf)__a, (imm)); })
+
+static __inline __m128 __attribute__((__always_inline__, __nodebug__))
+_mm_cvtph_ps(__m128i __a)
+{
+  return (__m128)__builtin_ia32_vcvtph2ps((__v8hi)__a);
+}
+
+static __inline __m256 __attribute__((__always_inline__, __nodebug__))
+_mm256_cvtph_ps(__m128i __a)
+{
+  return (__m256)__builtin_ia32_vcvtph2ps256((__v8hi)__a);
+}
+
+#endif /* __F16CINTRIN_H */
diff --git a/renderscript/clang-include/immintrin.h b/renderscript/clang-include/immintrin.h
index 15b65f3..cd733bf 100644
--- a/renderscript/clang-include/immintrin.h
+++ b/renderscript/clang-include/immintrin.h
@@ -98,4 +98,8 @@
 #endif
 #endif /* __RDRND__ */
 
+#ifdef __RTM__
+#include <rtmintrin.h>
+#endif
+
 #endif /* __IMMINTRIN_H */
diff --git a/renderscript/clang-include/mm_malloc.h b/renderscript/clang-include/mm_malloc.h
index 5fa1761..305afd3 100644
--- a/renderscript/clang-include/mm_malloc.h
+++ b/renderscript/clang-include/mm_malloc.h
@@ -30,45 +30,45 @@
 #include <malloc.h>
 #else
 #ifndef __cplusplus
-extern int posix_memalign(void **memptr, size_t alignment, size_t size);
+extern int posix_memalign(void **__memptr, size_t __alignment, size_t __size);
 #else
 // Some systems (e.g. those with GNU libc) declare posix_memalign with an
 // exception specifier. Via an "egregious workaround" in
 // Sema::CheckEquivalentExceptionSpec, Clang accepts the following as a valid
 // redeclaration of glibc's declaration.
-extern "C" int posix_memalign(void **memptr, size_t alignment, size_t size);
+extern "C" int posix_memalign(void **__memptr, size_t __alignment, size_t __size);
 #endif
 #endif
 
 #if !(defined(_WIN32) && defined(_mm_malloc))
 static __inline__ void *__attribute__((__always_inline__, __nodebug__,
                                        __malloc__))
-_mm_malloc(size_t size, size_t align)
+_mm_malloc(size_t __size, size_t __align)
 {
-  if (align == 1) {
-    return malloc(size);
+  if (__align == 1) {
+    return malloc(__size);
   }
 
-  if (!(align & (align - 1)) && align < sizeof(void *))
-    align = sizeof(void *);
+  if (!(__align & (__align - 1)) && __align < sizeof(void *))
+    __align = sizeof(void *);
 
-  void *mallocedMemory;
+  void *__mallocedMemory;
 #if defined(__MINGW32__)
-  mallocedMemory = __mingw_aligned_malloc(size, align);
+  __mallocedMemory = __mingw_aligned_malloc(__size, __align);
 #elif defined(_WIN32)
-  mallocedMemory = _aligned_malloc(size, align);
+  __mallocedMemory = _aligned_malloc(__size, __align);
 #else
-  if (posix_memalign(&mallocedMemory, align, size))
+  if (posix_memalign(&__mallocedMemory, __align, __size))
     return 0;
 #endif
 
-  return mallocedMemory;
+  return __mallocedMemory;
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_free(void *p)
+_mm_free(void *__p)
 {
-  free(p);
+  free(__p);
 }
 #endif
 
diff --git a/renderscript/clang-include/module.map b/renderscript/clang-include/module.map
deleted file mode 100644
index 418ba50..0000000
--- a/renderscript/clang-include/module.map
+++ /dev/null
@@ -1,108 +0,0 @@
-module _Builtin_intrinsics [system] {
-  explicit module altivec {
-    requires altivec
-    header "altivec.h"
-  }
-
-  explicit module intel {
-    requires x86
-    export *
-
-    header "immintrin.h"
-    header "x86intrin.h"
-
-    explicit module mm_malloc {
-      header "mm_malloc.h"
-      export * // note: for <stdlib.h> dependency
-    }
-
-    explicit module cpuid {
-      header "cpuid.h"
-    }
-
-    explicit module mmx {
-      requires mmx
-      header "mmintrin.h"
-    }
-
-    explicit module sse {
-      requires sse
-      export mmx
-      export * // note: for hackish <emmintrin.h> dependency
-      header "xmmintrin.h"
-    }
-
-    explicit module sse2 {
-      requires sse2
-      export sse
-      header "emmintrin.h"
-    }
-
-    explicit module sse3 {
-      requires sse3
-      export sse2
-      header "pmmintrin.h"
-    }
-
-    explicit module ssse3 {
-      requires ssse3
-      export sse3
-      header "tmmintrin.h"
-    }
-
-    explicit module sse4_1 {
-      requires sse41
-      export ssse3
-      header "smmintrin.h"
-    }
-
-    explicit module sse4_2 {
-      requires sse42
-      export sse4_1
-      header "nmmintrin.h"
-    }
-
-    explicit module avx {
-      requires avx
-      export sse4_2
-      header "avxintrin.h"
-    }
-
-    explicit module avx2 {
-      requires avx2
-      export avx
-      header "avx2intrin.h"
-    }
-
-    explicit module bmi {
-      requires bmi
-      header "bmiintrin.h"
-    }
-
-    explicit module bmi2 {
-      requires bmi2
-      header "bmi2intrin.h"
-    }
-
-    explicit module fma4 {
-      requires fma4
-      export sse3
-      header "fma4intrin.h"
-    }
-
-    explicit module lzcnt {
-      requires lzcnt
-      header "lzcntintrin.h"
-    }
-
-    explicit module popcnt {
-      requires popcnt
-      header "popcntintrin.h"
-    }
-
-    explicit module mm3dnow {
-      requires mm3dnow
-      header "mm3dnow.h"
-    }
-  }
-}
diff --git a/renderscript/clang-include/pmmintrin.h b/renderscript/clang-include/pmmintrin.h
index 5f9b097..6f1fc32 100644
--- a/renderscript/clang-include/pmmintrin.h
+++ b/renderscript/clang-include/pmmintrin.h
@@ -31,65 +31,65 @@
 #include <emmintrin.h>
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_lddqu_si128(__m128i const *p)
+_mm_lddqu_si128(__m128i const *__p)
 {
-  return (__m128i)__builtin_ia32_lddqu((char const *)p);
+  return (__m128i)__builtin_ia32_lddqu((char const *)__p);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_addsub_ps(__m128 a, __m128 b)
+_mm_addsub_ps(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_addsubps(a, b);
+  return __builtin_ia32_addsubps(__a, __b);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_hadd_ps(__m128 a, __m128 b)
+_mm_hadd_ps(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_haddps(a, b);
+  return __builtin_ia32_haddps(__a, __b);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_hsub_ps(__m128 a, __m128 b)
+_mm_hsub_ps(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_hsubps(a, b);
+  return __builtin_ia32_hsubps(__a, __b);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_movehdup_ps(__m128 a)
+_mm_movehdup_ps(__m128 __a)
 {
-  return __builtin_shufflevector(a, a, 1, 1, 3, 3);
+  return __builtin_shufflevector(__a, __a, 1, 1, 3, 3);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_moveldup_ps(__m128 a)
+_mm_moveldup_ps(__m128 __a)
 {
-  return __builtin_shufflevector(a, a, 0, 0, 2, 2);
+  return __builtin_shufflevector(__a, __a, 0, 0, 2, 2);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_addsub_pd(__m128d a, __m128d b)
+_mm_addsub_pd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_addsubpd(a, b);
+  return __builtin_ia32_addsubpd(__a, __b);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_hadd_pd(__m128d a, __m128d b)
+_mm_hadd_pd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_haddpd(a, b);
+  return __builtin_ia32_haddpd(__a, __b);
 }
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_hsub_pd(__m128d a, __m128d b)
+_mm_hsub_pd(__m128d __a, __m128d __b)
 {
-  return __builtin_ia32_hsubpd(a, b);
+  return __builtin_ia32_hsubpd(__a, __b);
 }
 
 #define        _mm_loaddup_pd(dp)        _mm_load1_pd(dp)
 
 static __inline__ __m128d __attribute__((__always_inline__, __nodebug__))
-_mm_movedup_pd(__m128d a)
+_mm_movedup_pd(__m128d __a)
 {
-  return __builtin_shufflevector(a, a, 0, 0);
+  return __builtin_shufflevector(__a, __a, 0, 0);
 }
 
 #define _MM_DENORMALS_ZERO_ON   (0x0040)
@@ -101,15 +101,15 @@
 #define _MM_SET_DENORMALS_ZERO_MODE(x) (_mm_setcsr((_mm_getcsr() & ~_MM_DENORMALS_ZERO_MASK) | (x)))
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_monitor(void const *p, unsigned extensions, unsigned hints)
+_mm_monitor(void const *__p, unsigned __extensions, unsigned __hints)
 {
-  __builtin_ia32_monitor((void *)p, extensions, hints);
+  __builtin_ia32_monitor((void *)__p, __extensions, __hints);
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_mwait(unsigned extensions, unsigned hints)
+_mm_mwait(unsigned __extensions, unsigned __hints)
 {
-  __builtin_ia32_mwait(extensions, hints);
+  __builtin_ia32_mwait(__extensions, __hints);
 }
 
 #endif /* __SSE3__ */
diff --git a/renderscript/clang-include/rtmintrin.h b/renderscript/clang-include/rtmintrin.h
new file mode 100644
index 0000000..bdc2b99
--- /dev/null
+++ b/renderscript/clang-include/rtmintrin.h
@@ -0,0 +1,49 @@
+/*===---- rtmintrin.h - RTM intrinsics -------------------------------------===
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <rtmintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#define _XBEGIN_STARTED   (~0u)
+#define _XABORT_EXPLICIT  (1 << 0)
+#define _XABORT_RETRY     (1 << 1)
+#define _XABORT_CONFLICT  (1 << 2)
+#define _XABORT_CAPACITY  (1 << 3)
+#define _XABORT_DEBUG     (1 << 4)
+#define _XABORT_NESTED    (1 << 5)
+#define _XABORT_CODE(x)   (((x) >> 24) & 0xFF)
+
+static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__))
+_xbegin(void)
+{
+  return __builtin_ia32_xbegin();
+}
+
+static __inline__ void __attribute__((__always_inline__, __nodebug__))
+_xend(void)
+{
+  __builtin_ia32_xend();
+}
+
+#define _xabort(imm) __builtin_ia32_xabort((imm))
diff --git a/renderscript/clang-include/smmintrin.h b/renderscript/clang-include/smmintrin.h
index 2fab50e..498f6f0 100644
--- a/renderscript/clang-include/smmintrin.h
+++ b/renderscript/clang-include/smmintrin.h
@@ -195,10 +195,10 @@
 /* SSE4 Insertion and Extraction from XMM Register Instructions.  */
 #define _mm_insert_ps(X, Y, N) __builtin_ia32_insertps128((X), (Y), (N))
 #define _mm_extract_ps(X, N) (__extension__                      \
-                              ({ union { int i; float f; } __t;  \
+                              ({ union { int __i; float __f; } __t;  \
                                  __v4sf __a = (__v4sf)(X);       \
-                                 __t.f = __a[N];                 \
-                                 __t.i;}))
+                                 __t.__f = __a[N];                 \
+                                 __t.__i;}))
 
 /* Miscellaneous insert and extract macros.  */
 /* Extract a single-precision float from X at index N into D.  */
diff --git a/renderscript/clang-include/stdalign.h b/renderscript/clang-include/stdalign.h
index e7fbfa0..3738d12 100644
--- a/renderscript/clang-include/stdalign.h
+++ b/renderscript/clang-include/stdalign.h
@@ -24,7 +24,12 @@
 #ifndef __STDALIGN_H
 #define __STDALIGN_H
 
+#ifndef __cplusplus
 #define alignas _Alignas
+#define alignof _Alignof
+#endif
+
 #define __alignas_is_defined 1
+#define __alignof_is_defined 1
 
 #endif /* __STDALIGN_H */
diff --git a/renderscript/clang-include/stddef.h b/renderscript/clang-include/stddef.h
index eb919b5..ad5dc21 100644
--- a/renderscript/clang-include/stddef.h
+++ b/renderscript/clang-include/stddef.h
@@ -28,11 +28,11 @@
 
 #ifndef _PTRDIFF_T
 #define _PTRDIFF_T
-typedef __typeof__(((int*)0)-((int*)0)) ptrdiff_t;
+typedef __PTRDIFF_TYPE__ ptrdiff_t;
 #endif
 #ifndef _SIZE_T
 #define _SIZE_T
-typedef __typeof__(sizeof(int)) size_t;
+typedef __SIZE_TYPE__ size_t;
 #endif
 #ifndef __cplusplus
 #ifndef _WCHAR_T
diff --git a/renderscript/clang-include/stdnoreturn.h b/renderscript/clang-include/stdnoreturn.h
new file mode 100644
index 0000000..a7a301d
--- /dev/null
+++ b/renderscript/clang-include/stdnoreturn.h
@@ -0,0 +1,30 @@
+/*===---- stdnoreturn.h - Standard header for noreturn macro ---------------===
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __STDNORETURN_H
+#define __STDNORETURN_H
+
+#define noreturn _Noreturn
+#define __noreturn_is_defined 1
+
+#endif /* __STDNORETURN_H */
diff --git a/renderscript/clang-include/tmmintrin.h b/renderscript/clang-include/tmmintrin.h
index a62c6cc..4238f5b 100644
--- a/renderscript/clang-include/tmmintrin.h
+++ b/renderscript/clang-include/tmmintrin.h
@@ -31,39 +31,39 @@
 #include <pmmintrin.h>
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_abs_pi8(__m64 a)
+_mm_abs_pi8(__m64 __a)
 {
-    return (__m64)__builtin_ia32_pabsb((__v8qi)a);
+    return (__m64)__builtin_ia32_pabsb((__v8qi)__a);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_abs_epi8(__m128i a)
+_mm_abs_epi8(__m128i __a)
 {
-    return (__m128i)__builtin_ia32_pabsb128((__v16qi)a);
+    return (__m128i)__builtin_ia32_pabsb128((__v16qi)__a);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_abs_pi16(__m64 a)
+_mm_abs_pi16(__m64 __a)
 {
-    return (__m64)__builtin_ia32_pabsw((__v4hi)a);
+    return (__m64)__builtin_ia32_pabsw((__v4hi)__a);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_abs_epi16(__m128i a)
+_mm_abs_epi16(__m128i __a)
 {
-    return (__m128i)__builtin_ia32_pabsw128((__v8hi)a);
+    return (__m128i)__builtin_ia32_pabsw128((__v8hi)__a);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_abs_pi32(__m64 a)
+_mm_abs_pi32(__m64 __a)
 {
-    return (__m64)__builtin_ia32_pabsd((__v2si)a);
+    return (__m64)__builtin_ia32_pabsd((__v2si)__a);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_abs_epi32(__m128i a)
+_mm_abs_epi32(__m128i __a)
 {
-    return (__m128i)__builtin_ia32_pabsd128((__v4si)a);
+    return (__m128i)__builtin_ia32_pabsd128((__v4si)__a);
 }
 
 #define _mm_alignr_epi8(a, b, n) __extension__ ({ \
@@ -77,147 +77,147 @@
   (__m64)__builtin_ia32_palignr((__v8qi)__a, (__v8qi)__b, (n)); })
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_hadd_epi16(__m128i a, __m128i b)
+_mm_hadd_epi16(__m128i __a, __m128i __b)
 {
-    return (__m128i)__builtin_ia32_phaddw128((__v8hi)a, (__v8hi)b);
+    return (__m128i)__builtin_ia32_phaddw128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_hadd_epi32(__m128i a, __m128i b)
+_mm_hadd_epi32(__m128i __a, __m128i __b)
 {
-    return (__m128i)__builtin_ia32_phaddd128((__v4si)a, (__v4si)b);
+    return (__m128i)__builtin_ia32_phaddd128((__v4si)__a, (__v4si)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_hadd_pi16(__m64 a, __m64 b)
+_mm_hadd_pi16(__m64 __a, __m64 __b)
 {
-    return (__m64)__builtin_ia32_phaddw((__v4hi)a, (__v4hi)b);
+    return (__m64)__builtin_ia32_phaddw((__v4hi)__a, (__v4hi)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_hadd_pi32(__m64 a, __m64 b)
+_mm_hadd_pi32(__m64 __a, __m64 __b)
 {
-    return (__m64)__builtin_ia32_phaddd((__v2si)a, (__v2si)b);
+    return (__m64)__builtin_ia32_phaddd((__v2si)__a, (__v2si)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_hadds_epi16(__m128i a, __m128i b)
+_mm_hadds_epi16(__m128i __a, __m128i __b)
 {
-    return (__m128i)__builtin_ia32_phaddsw128((__v8hi)a, (__v8hi)b);
+    return (__m128i)__builtin_ia32_phaddsw128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_hadds_pi16(__m64 a, __m64 b)
+_mm_hadds_pi16(__m64 __a, __m64 __b)
 {
-    return (__m64)__builtin_ia32_phaddsw((__v4hi)a, (__v4hi)b);
+    return (__m64)__builtin_ia32_phaddsw((__v4hi)__a, (__v4hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_hsub_epi16(__m128i a, __m128i b)
+_mm_hsub_epi16(__m128i __a, __m128i __b)
 {
-    return (__m128i)__builtin_ia32_phsubw128((__v8hi)a, (__v8hi)b);
+    return (__m128i)__builtin_ia32_phsubw128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_hsub_epi32(__m128i a, __m128i b)
+_mm_hsub_epi32(__m128i __a, __m128i __b)
 {
-    return (__m128i)__builtin_ia32_phsubd128((__v4si)a, (__v4si)b);
+    return (__m128i)__builtin_ia32_phsubd128((__v4si)__a, (__v4si)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_hsub_pi16(__m64 a, __m64 b)
+_mm_hsub_pi16(__m64 __a, __m64 __b)
 {
-    return (__m64)__builtin_ia32_phsubw((__v4hi)a, (__v4hi)b);
+    return (__m64)__builtin_ia32_phsubw((__v4hi)__a, (__v4hi)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_hsub_pi32(__m64 a, __m64 b)
+_mm_hsub_pi32(__m64 __a, __m64 __b)
 {
-    return (__m64)__builtin_ia32_phsubd((__v2si)a, (__v2si)b);
+    return (__m64)__builtin_ia32_phsubd((__v2si)__a, (__v2si)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_hsubs_epi16(__m128i a, __m128i b)
+_mm_hsubs_epi16(__m128i __a, __m128i __b)
 {
-    return (__m128i)__builtin_ia32_phsubsw128((__v8hi)a, (__v8hi)b);
+    return (__m128i)__builtin_ia32_phsubsw128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_hsubs_pi16(__m64 a, __m64 b)
+_mm_hsubs_pi16(__m64 __a, __m64 __b)
 {
-    return (__m64)__builtin_ia32_phsubsw((__v4hi)a, (__v4hi)b);
+    return (__m64)__builtin_ia32_phsubsw((__v4hi)__a, (__v4hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_maddubs_epi16(__m128i a, __m128i b)
+_mm_maddubs_epi16(__m128i __a, __m128i __b)
 {
-    return (__m128i)__builtin_ia32_pmaddubsw128((__v16qi)a, (__v16qi)b);
+    return (__m128i)__builtin_ia32_pmaddubsw128((__v16qi)__a, (__v16qi)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_maddubs_pi16(__m64 a, __m64 b)
+_mm_maddubs_pi16(__m64 __a, __m64 __b)
 {
-    return (__m64)__builtin_ia32_pmaddubsw((__v8qi)a, (__v8qi)b);
+    return (__m64)__builtin_ia32_pmaddubsw((__v8qi)__a, (__v8qi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_mulhrs_epi16(__m128i a, __m128i b)
+_mm_mulhrs_epi16(__m128i __a, __m128i __b)
 {
-    return (__m128i)__builtin_ia32_pmulhrsw128((__v8hi)a, (__v8hi)b);
+    return (__m128i)__builtin_ia32_pmulhrsw128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_mulhrs_pi16(__m64 a, __m64 b)
+_mm_mulhrs_pi16(__m64 __a, __m64 __b)
 {
-    return (__m64)__builtin_ia32_pmulhrsw((__v4hi)a, (__v4hi)b);
+    return (__m64)__builtin_ia32_pmulhrsw((__v4hi)__a, (__v4hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_shuffle_epi8(__m128i a, __m128i b)
+_mm_shuffle_epi8(__m128i __a, __m128i __b)
 {
-    return (__m128i)__builtin_ia32_pshufb128((__v16qi)a, (__v16qi)b);
+    return (__m128i)__builtin_ia32_pshufb128((__v16qi)__a, (__v16qi)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_shuffle_pi8(__m64 a, __m64 b)
+_mm_shuffle_pi8(__m64 __a, __m64 __b)
 {
-    return (__m64)__builtin_ia32_pshufb((__v8qi)a, (__v8qi)b);
+    return (__m64)__builtin_ia32_pshufb((__v8qi)__a, (__v8qi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_sign_epi8(__m128i a, __m128i b)
+_mm_sign_epi8(__m128i __a, __m128i __b)
 {
-    return (__m128i)__builtin_ia32_psignb128((__v16qi)a, (__v16qi)b);
+    return (__m128i)__builtin_ia32_psignb128((__v16qi)__a, (__v16qi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_sign_epi16(__m128i a, __m128i b)
+_mm_sign_epi16(__m128i __a, __m128i __b)
 {
-    return (__m128i)__builtin_ia32_psignw128((__v8hi)a, (__v8hi)b);
+    return (__m128i)__builtin_ia32_psignw128((__v8hi)__a, (__v8hi)__b);
 }
 
 static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_sign_epi32(__m128i a, __m128i b)
+_mm_sign_epi32(__m128i __a, __m128i __b)
 {
-    return (__m128i)__builtin_ia32_psignd128((__v4si)a, (__v4si)b);
+    return (__m128i)__builtin_ia32_psignd128((__v4si)__a, (__v4si)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_sign_pi8(__m64 a, __m64 b)
+_mm_sign_pi8(__m64 __a, __m64 __b)
 {
-    return (__m64)__builtin_ia32_psignb((__v8qi)a, (__v8qi)b);  
+    return (__m64)__builtin_ia32_psignb((__v8qi)__a, (__v8qi)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_sign_pi16(__m64 a, __m64 b)
+_mm_sign_pi16(__m64 __a, __m64 __b)
 {
-    return (__m64)__builtin_ia32_psignw((__v4hi)a, (__v4hi)b);  
+    return (__m64)__builtin_ia32_psignw((__v4hi)__a, (__v4hi)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_sign_pi32(__m64 a, __m64 b)
+_mm_sign_pi32(__m64 __a, __m64 __b)
 {
-    return (__m64)__builtin_ia32_psignd((__v2si)a, (__v2si)b);
+    return (__m64)__builtin_ia32_psignd((__v2si)__a, (__v2si)__b);
 }
 
 #endif /* __SSSE3__ */
diff --git a/renderscript/clang-include/unwind.h b/renderscript/clang-include/unwind.h
index a065920..e94fd70 100644
--- a/renderscript/clang-include/unwind.h
+++ b/renderscript/clang-include/unwind.h
@@ -23,6 +23,9 @@
 
 /* See "Data Definitions for libgcc_s" in the Linux Standard Base.*/
 
+#ifndef __CLANG_UNWIND_H
+#define __CLANG_UNWIND_H
+
 #if __has_include_next(<unwind.h>)
 /* Darwin and libunwind provide an unwind.h. If that's available, use
  * it. libunwind wraps some of its definitions in #ifdef _GNU_SOURCE,
@@ -59,7 +62,9 @@
 /* It is a bit strange for a header to play with the visibility of the
    symbols it declares, but this matches gcc's behavior and some programs
    depend on it */
+#ifndef HIDE_EXPORTS
 #pragma GCC visibility push(default)
+#endif
 
 struct _Unwind_Context;
 typedef enum {
@@ -79,46 +84,50 @@
 
 #ifdef __arm__
 
-typedef enum { 
-  _UVRSC_CORE = 0,        /* integer register */ 
-  _UVRSC_VFP = 1,         /* vfp */ 
-  _UVRSC_WMMXD = 3,       /* Intel WMMX data register */ 
-  _UVRSC_WMMXC = 4        /* Intel WMMX control register */ 
-} _Unwind_VRS_RegClass; 
+typedef enum {
+  _UVRSC_CORE = 0,        /* integer register */
+  _UVRSC_VFP = 1,         /* vfp */
+  _UVRSC_WMMXD = 3,       /* Intel WMMX data register */
+  _UVRSC_WMMXC = 4        /* Intel WMMX control register */
+} _Unwind_VRS_RegClass;
 
-typedef enum { 
-  _UVRSD_UINT32 = 0,  
-  _UVRSD_VFPX = 1,  
-  _UVRSD_UINT64 = 3,  
-  _UVRSD_FLOAT = 4,  
-  _UVRSD_DOUBLE = 5 
-} _Unwind_VRS_DataRepresentation; 
+typedef enum {
+  _UVRSD_UINT32 = 0,
+  _UVRSD_VFPX = 1,
+  _UVRSD_UINT64 = 3,
+  _UVRSD_FLOAT = 4,
+  _UVRSD_DOUBLE = 5
+} _Unwind_VRS_DataRepresentation;
 
-typedef enum { 
-  _UVRSR_OK = 0,  
-  _UVRSR_NOT_IMPLEMENTED = 1,  
-  _UVRSR_FAILED = 2  
-} _Unwind_VRS_Result; 
+typedef enum {
+  _UVRSR_OK = 0,
+  _UVRSR_NOT_IMPLEMENTED = 1,
+  _UVRSR_FAILED = 2
+} _Unwind_VRS_Result;
 
-_Unwind_VRS_Result _Unwind_VRS_Get(_Unwind_Context *context,
-  _Unwind_VRS_RegClass regclass,
-  uint32_t regno,
-  _Unwind_VRS_DataRepresentation representation,
-  void *valuep);
+_Unwind_VRS_Result _Unwind_VRS_Get(struct _Unwind_Context *__context,
+  _Unwind_VRS_RegClass __regclass,
+  uint32_t __regno,
+  _Unwind_VRS_DataRepresentation __representation,
+  void *__valuep);
 
 #else
 
-uintptr_t _Unwind_GetIP(struct _Unwind_Context* context);
+uintptr_t _Unwind_GetIP(struct _Unwind_Context* __context);
 
 #endif
 
 typedef _Unwind_Reason_Code (*_Unwind_Trace_Fn)(struct _Unwind_Context*, void*);
 _Unwind_Reason_Code _Unwind_Backtrace(_Unwind_Trace_Fn, void*);
 
+#ifndef HIDE_EXPORTS
 #pragma GCC visibility pop
+#endif
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif
+
+#endif /* __CLANG_UNWIND_H */
diff --git a/renderscript/clang-include/wmmintrin.h b/renderscript/clang-include/wmmintrin.h
index dca896f..369e3c2 100644
--- a/renderscript/clang-include/wmmintrin.h
+++ b/renderscript/clang-include/wmmintrin.h
@@ -31,48 +31,11 @@
 #else
 
 #ifdef __AES__
-
-static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_aesenc_si128(__m128i __V, __m128i __R)
-{
-  return (__m128i)__builtin_ia32_aesenc128(__V, __R);
-}
-
-static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_aesenclast_si128(__m128i __V, __m128i __R)
-{
-  return (__m128i)__builtin_ia32_aesenclast128(__V, __R);
-}
-
-static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_aesdec_si128(__m128i __V, __m128i __R)
-{
-  return (__m128i)__builtin_ia32_aesdec128(__V, __R);
-}
-
-static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_aesdeclast_si128(__m128i __V, __m128i __R)
-{
-  return (__m128i)__builtin_ia32_aesdeclast128(__V, __R);
-}
-
-static __inline__ __m128i __attribute__((__always_inline__, __nodebug__))
-_mm_aesimc_si128(__m128i __V)
-{
-  return (__m128i)__builtin_ia32_aesimc128(__V);
-}
-
-#define _mm_aeskeygenassist_si128(C, R) \
-  __builtin_ia32_aeskeygenassist128((C), (R))
-
+#include <__wmmintrin_aes.h>
 #endif /* __AES__ */
 
 #ifdef __PCLMUL__
-
-#define _mm_clmulepi64_si128(__X, __Y, __I) \
-  ((__m128i)__builtin_ia32_pclmulqdq128((__v2di)(__m128i)(__X), \
-                                        (__v2di)(__m128i)(__Y), (char)(__I)))
-
+#include <__wmmintrin_pclmul.h>
 #endif /* __PCLMUL__ */
 
 #endif /* __AES__ || __PCLMUL__ */
diff --git a/renderscript/clang-include/x86intrin.h b/renderscript/clang-include/x86intrin.h
index 556cd01..68ce106 100644
--- a/renderscript/clang-include/x86intrin.h
+++ b/renderscript/clang-include/x86intrin.h
@@ -58,6 +58,10 @@
 #include <xopintrin.h>
 #endif
 
+#ifdef __F16C__
+#include <f16cintrin.h>
+#endif
+
 // FIXME: LWP
 
 #endif /* __X86INTRIN_H */
diff --git a/renderscript/clang-include/xmmintrin.h b/renderscript/clang-include/xmmintrin.h
index e616157..b3b23cb 100644
--- a/renderscript/clang-include/xmmintrin.h
+++ b/renderscript/clang-include/xmmintrin.h
@@ -41,560 +41,563 @@
 #endif
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_add_ss(__m128 a, __m128 b)
+_mm_add_ss(__m128 __a, __m128 __b)
 {
-  a[0] += b[0];
-  return a;
+  __a[0] += __b[0];
+  return __a;
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_add_ps(__m128 a, __m128 b)
+_mm_add_ps(__m128 __a, __m128 __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_sub_ss(__m128 a, __m128 b)
+_mm_sub_ss(__m128 __a, __m128 __b)
 {
-  a[0] -= b[0];
-  return a;
+  __a[0] -= __b[0];
+  return __a;
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_sub_ps(__m128 a, __m128 b)
+_mm_sub_ps(__m128 __a, __m128 __b)
 {
-  return a - b;
+  return __a - __b;
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_mul_ss(__m128 a, __m128 b)
+_mm_mul_ss(__m128 __a, __m128 __b)
 {
-  a[0] *= b[0];
-  return a;
+  __a[0] *= __b[0];
+  return __a;
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_mul_ps(__m128 a, __m128 b)
+_mm_mul_ps(__m128 __a, __m128 __b)
 {
-  return a * b;
+  return __a * __b;
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_div_ss(__m128 a, __m128 b)
+_mm_div_ss(__m128 __a, __m128 __b)
 {
-  a[0] /= b[0];
-  return a;
+  __a[0] /= __b[0];
+  return __a;
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_div_ps(__m128 a, __m128 b)
+_mm_div_ps(__m128 __a, __m128 __b)
 {
-  return a / b;
+  return __a / __b;
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_sqrt_ss(__m128 a)
+_mm_sqrt_ss(__m128 __a)
 {
-  return __builtin_ia32_sqrtss(a);
+  __m128 __c = __builtin_ia32_sqrtss(__a);
+  return (__m128) { __c[0], __a[1], __a[2], __a[3] };
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_sqrt_ps(__m128 a)
+_mm_sqrt_ps(__m128 __a)
 {
-  return __builtin_ia32_sqrtps(a);
+  return __builtin_ia32_sqrtps(__a);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_rcp_ss(__m128 a)
+_mm_rcp_ss(__m128 __a)
 {
-  return __builtin_ia32_rcpss(a);
+  __m128 __c = __builtin_ia32_rcpss(__a);
+  return (__m128) { __c[0], __a[1], __a[2], __a[3] };
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_rcp_ps(__m128 a)
+_mm_rcp_ps(__m128 __a)
 {
-  return __builtin_ia32_rcpps(a);
+  return __builtin_ia32_rcpps(__a);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_rsqrt_ss(__m128 a)
+_mm_rsqrt_ss(__m128 __a)
 {
-  return __builtin_ia32_rsqrtss(a);
+  __m128 __c = __builtin_ia32_rsqrtss(__a);
+  return (__m128) { __c[0], __a[1], __a[2], __a[3] };
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_rsqrt_ps(__m128 a)
+_mm_rsqrt_ps(__m128 __a)
 {
-  return __builtin_ia32_rsqrtps(a);
+  return __builtin_ia32_rsqrtps(__a);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_min_ss(__m128 a, __m128 b)
+_mm_min_ss(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_minss(a, b);
+  return __builtin_ia32_minss(__a, __b);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_min_ps(__m128 a, __m128 b)
+_mm_min_ps(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_minps(a, b);
+  return __builtin_ia32_minps(__a, __b);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_max_ss(__m128 a, __m128 b)
+_mm_max_ss(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_maxss(a, b);
+  return __builtin_ia32_maxss(__a, __b);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_max_ps(__m128 a, __m128 b)
+_mm_max_ps(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_maxps(a, b);
+  return __builtin_ia32_maxps(__a, __b);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_and_ps(__m128 a, __m128 b)
+_mm_and_ps(__m128 __a, __m128 __b)
 {
-  return (__m128)((__v4si)a & (__v4si)b);
+  return (__m128)((__v4si)__a & (__v4si)__b);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_andnot_ps(__m128 a, __m128 b)
+_mm_andnot_ps(__m128 __a, __m128 __b)
 {
-  return (__m128)(~(__v4si)a & (__v4si)b);
+  return (__m128)(~(__v4si)__a & (__v4si)__b);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_or_ps(__m128 a, __m128 b)
+_mm_or_ps(__m128 __a, __m128 __b)
 {
-  return (__m128)((__v4si)a | (__v4si)b);
+  return (__m128)((__v4si)__a | (__v4si)__b);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_xor_ps(__m128 a, __m128 b)
+_mm_xor_ps(__m128 __a, __m128 __b)
 {
-  return (__m128)((__v4si)a ^ (__v4si)b);
+  return (__m128)((__v4si)__a ^ (__v4si)__b);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpeq_ss(__m128 a, __m128 b)
+_mm_cmpeq_ss(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpss(a, b, 0);
+  return (__m128)__builtin_ia32_cmpss(__a, __b, 0);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpeq_ps(__m128 a, __m128 b)
+_mm_cmpeq_ps(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpps(a, b, 0);
+  return (__m128)__builtin_ia32_cmpps(__a, __b, 0);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmplt_ss(__m128 a, __m128 b)
+_mm_cmplt_ss(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpss(a, b, 1);
+  return (__m128)__builtin_ia32_cmpss(__a, __b, 1);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmplt_ps(__m128 a, __m128 b)
+_mm_cmplt_ps(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpps(a, b, 1);
+  return (__m128)__builtin_ia32_cmpps(__a, __b, 1);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmple_ss(__m128 a, __m128 b)
+_mm_cmple_ss(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpss(a, b, 2);
+  return (__m128)__builtin_ia32_cmpss(__a, __b, 2);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmple_ps(__m128 a, __m128 b)
+_mm_cmple_ps(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpps(a, b, 2);
+  return (__m128)__builtin_ia32_cmpps(__a, __b, 2);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpgt_ss(__m128 a, __m128 b)
+_mm_cmpgt_ss(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpss(b, a, 1);
+  return (__m128)__builtin_ia32_cmpss(__b, __a, 1);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpgt_ps(__m128 a, __m128 b)
+_mm_cmpgt_ps(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpps(b, a, 1);
+  return (__m128)__builtin_ia32_cmpps(__b, __a, 1);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpge_ss(__m128 a, __m128 b)
+_mm_cmpge_ss(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpss(b, a, 2);
+  return (__m128)__builtin_ia32_cmpss(__b, __a, 2);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpge_ps(__m128 a, __m128 b)
+_mm_cmpge_ps(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpps(b, a, 2);
+  return (__m128)__builtin_ia32_cmpps(__b, __a, 2);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpneq_ss(__m128 a, __m128 b)
+_mm_cmpneq_ss(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpss(a, b, 4);
+  return (__m128)__builtin_ia32_cmpss(__a, __b, 4);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpneq_ps(__m128 a, __m128 b)
+_mm_cmpneq_ps(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpps(a, b, 4);
+  return (__m128)__builtin_ia32_cmpps(__a, __b, 4);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpnlt_ss(__m128 a, __m128 b)
+_mm_cmpnlt_ss(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpss(a, b, 5);
+  return (__m128)__builtin_ia32_cmpss(__a, __b, 5);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpnlt_ps(__m128 a, __m128 b)
+_mm_cmpnlt_ps(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpps(a, b, 5);
+  return (__m128)__builtin_ia32_cmpps(__a, __b, 5);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpnle_ss(__m128 a, __m128 b)
+_mm_cmpnle_ss(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpss(a, b, 6);
+  return (__m128)__builtin_ia32_cmpss(__a, __b, 6);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpnle_ps(__m128 a, __m128 b)
+_mm_cmpnle_ps(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpps(a, b, 6);
+  return (__m128)__builtin_ia32_cmpps(__a, __b, 6);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpngt_ss(__m128 a, __m128 b)
+_mm_cmpngt_ss(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpss(b, a, 5);
+  return (__m128)__builtin_ia32_cmpss(__b, __a, 5);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpngt_ps(__m128 a, __m128 b)
+_mm_cmpngt_ps(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpps(b, a, 5);
+  return (__m128)__builtin_ia32_cmpps(__b, __a, 5);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpnge_ss(__m128 a, __m128 b)
+_mm_cmpnge_ss(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpss(b, a, 6);
+  return (__m128)__builtin_ia32_cmpss(__b, __a, 6);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpnge_ps(__m128 a, __m128 b)
+_mm_cmpnge_ps(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpps(b, a, 6);
+  return (__m128)__builtin_ia32_cmpps(__b, __a, 6);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpord_ss(__m128 a, __m128 b)
+_mm_cmpord_ss(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpss(a, b, 7);
+  return (__m128)__builtin_ia32_cmpss(__a, __b, 7);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpord_ps(__m128 a, __m128 b)
+_mm_cmpord_ps(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpps(a, b, 7);
+  return (__m128)__builtin_ia32_cmpps(__a, __b, 7);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpunord_ss(__m128 a, __m128 b)
+_mm_cmpunord_ss(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpss(a, b, 3);
+  return (__m128)__builtin_ia32_cmpss(__a, __b, 3);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cmpunord_ps(__m128 a, __m128 b)
+_mm_cmpunord_ps(__m128 __a, __m128 __b)
 {
-  return (__m128)__builtin_ia32_cmpps(a, b, 3);
+  return (__m128)__builtin_ia32_cmpps(__a, __b, 3);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_comieq_ss(__m128 a, __m128 b)
+_mm_comieq_ss(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_comieq(a, b);
+  return __builtin_ia32_comieq(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_comilt_ss(__m128 a, __m128 b)
+_mm_comilt_ss(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_comilt(a, b);
+  return __builtin_ia32_comilt(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_comile_ss(__m128 a, __m128 b)
+_mm_comile_ss(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_comile(a, b);
+  return __builtin_ia32_comile(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_comigt_ss(__m128 a, __m128 b)
+_mm_comigt_ss(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_comigt(a, b);
+  return __builtin_ia32_comigt(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_comige_ss(__m128 a, __m128 b)
+_mm_comige_ss(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_comige(a, b);
+  return __builtin_ia32_comige(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_comineq_ss(__m128 a, __m128 b)
+_mm_comineq_ss(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_comineq(a, b);
+  return __builtin_ia32_comineq(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_ucomieq_ss(__m128 a, __m128 b)
+_mm_ucomieq_ss(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_ucomieq(a, b);
+  return __builtin_ia32_ucomieq(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_ucomilt_ss(__m128 a, __m128 b)
+_mm_ucomilt_ss(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_ucomilt(a, b);
+  return __builtin_ia32_ucomilt(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_ucomile_ss(__m128 a, __m128 b)
+_mm_ucomile_ss(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_ucomile(a, b);
+  return __builtin_ia32_ucomile(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_ucomigt_ss(__m128 a, __m128 b)
+_mm_ucomigt_ss(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_ucomigt(a, b);
+  return __builtin_ia32_ucomigt(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_ucomige_ss(__m128 a, __m128 b)
+_mm_ucomige_ss(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_ucomige(a, b);
+  return __builtin_ia32_ucomige(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_ucomineq_ss(__m128 a, __m128 b)
+_mm_ucomineq_ss(__m128 __a, __m128 __b)
 {
-  return __builtin_ia32_ucomineq(a, b);
+  return __builtin_ia32_ucomineq(__a, __b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_cvtss_si32(__m128 a)
+_mm_cvtss_si32(__m128 __a)
 {
-  return __builtin_ia32_cvtss2si(a);
+  return __builtin_ia32_cvtss2si(__a);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_cvt_ss2si(__m128 a)
+_mm_cvt_ss2si(__m128 __a)
 {
-  return _mm_cvtss_si32(a);
+  return _mm_cvtss_si32(__a);
 }
 
 #ifdef __x86_64__
 
 static __inline__ long long __attribute__((__always_inline__, __nodebug__))
-_mm_cvtss_si64(__m128 a)
+_mm_cvtss_si64(__m128 __a)
 {
-  return __builtin_ia32_cvtss2si64(a);
+  return __builtin_ia32_cvtss2si64(__a);
 }
 
 #endif
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_cvtps_pi32(__m128 a)
+_mm_cvtps_pi32(__m128 __a)
 {
-  return (__m64)__builtin_ia32_cvtps2pi(a);
+  return (__m64)__builtin_ia32_cvtps2pi(__a);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_cvt_ps2pi(__m128 a)
+_mm_cvt_ps2pi(__m128 __a)
 {
-  return _mm_cvtps_pi32(a);
+  return _mm_cvtps_pi32(__a);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_cvttss_si32(__m128 a)
+_mm_cvttss_si32(__m128 __a)
 {
-  return a[0];
+  return __a[0];
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_cvtt_ss2si(__m128 a)
+_mm_cvtt_ss2si(__m128 __a)
 {
-  return _mm_cvttss_si32(a);
+  return _mm_cvttss_si32(__a);
 }
 
 static __inline__ long long __attribute__((__always_inline__, __nodebug__))
-_mm_cvttss_si64(__m128 a)
+_mm_cvttss_si64(__m128 __a)
 {
-  return a[0];
+  return __a[0];
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_cvttps_pi32(__m128 a)
+_mm_cvttps_pi32(__m128 __a)
 {
-  return (__m64)__builtin_ia32_cvttps2pi(a);
+  return (__m64)__builtin_ia32_cvttps2pi(__a);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_cvtt_ps2pi(__m128 a)
+_mm_cvtt_ps2pi(__m128 __a)
 {
-  return _mm_cvttps_pi32(a);
+  return _mm_cvttps_pi32(__a);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cvtsi32_ss(__m128 a, int b)
+_mm_cvtsi32_ss(__m128 __a, int __b)
 {
-  a[0] = b;
-  return a;
+  __a[0] = __b;
+  return __a;
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cvt_si2ss(__m128 a, int b)
+_mm_cvt_si2ss(__m128 __a, int __b)
 {
-  return _mm_cvtsi32_ss(a, b);
+  return _mm_cvtsi32_ss(__a, __b);
 }
 
 #ifdef __x86_64__
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cvtsi64_ss(__m128 a, long long b)
+_mm_cvtsi64_ss(__m128 __a, long long __b)
 {
-  a[0] = b;
-  return a;
+  __a[0] = __b;
+  return __a;
 }
 
 #endif
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cvtpi32_ps(__m128 a, __m64 b)
+_mm_cvtpi32_ps(__m128 __a, __m64 __b)
 {
-  return __builtin_ia32_cvtpi2ps(a, (__v2si)b);
+  return __builtin_ia32_cvtpi2ps(__a, (__v2si)__b);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cvt_pi2ps(__m128 a, __m64 b)
+_mm_cvt_pi2ps(__m128 __a, __m64 __b)
 {
-  return _mm_cvtpi32_ps(a, b);
+  return _mm_cvtpi32_ps(__a, __b);
 }
 
 static __inline__ float __attribute__((__always_inline__, __nodebug__))
-_mm_cvtss_f32(__m128 a)
+_mm_cvtss_f32(__m128 __a)
 {
-  return a[0];
+  return __a[0];
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_loadh_pi(__m128 a, const __m64 *p)
+_mm_loadh_pi(__m128 __a, const __m64 *__p)
 {
   typedef float __mm_loadh_pi_v2f32 __attribute__((__vector_size__(8)));
   struct __mm_loadh_pi_struct {
-    __mm_loadh_pi_v2f32 u;
+    __mm_loadh_pi_v2f32 __u;
   } __attribute__((__packed__, __may_alias__));
-  __mm_loadh_pi_v2f32 b = ((struct __mm_loadh_pi_struct*)p)->u;
-  __m128 bb = __builtin_shufflevector(b, b, 0, 1, 0, 1);
-  return __builtin_shufflevector(a, bb, 0, 1, 4, 5);
+  __mm_loadh_pi_v2f32 __b = ((struct __mm_loadh_pi_struct*)__p)->__u;
+  __m128 __bb = __builtin_shufflevector(__b, __b, 0, 1, 0, 1);
+  return __builtin_shufflevector(__a, __bb, 0, 1, 4, 5);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_loadl_pi(__m128 a, const __m64 *p)
+_mm_loadl_pi(__m128 __a, const __m64 *__p)
 {
   typedef float __mm_loadl_pi_v2f32 __attribute__((__vector_size__(8)));
   struct __mm_loadl_pi_struct {
-    __mm_loadl_pi_v2f32 u;
+    __mm_loadl_pi_v2f32 __u;
   } __attribute__((__packed__, __may_alias__));
-  __mm_loadl_pi_v2f32 b = ((struct __mm_loadl_pi_struct*)p)->u;
-  __m128 bb = __builtin_shufflevector(b, b, 0, 1, 0, 1);
-  return __builtin_shufflevector(a, bb, 4, 5, 2, 3);
+  __mm_loadl_pi_v2f32 __b = ((struct __mm_loadl_pi_struct*)__p)->__u;
+  __m128 __bb = __builtin_shufflevector(__b, __b, 0, 1, 0, 1);
+  return __builtin_shufflevector(__a, __bb, 4, 5, 2, 3);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_load_ss(const float *p)
+_mm_load_ss(const float *__p)
 {
   struct __mm_load_ss_struct {
-    float u;
+    float __u;
   } __attribute__((__packed__, __may_alias__));
-  float u = ((struct __mm_load_ss_struct*)p)->u;
-  return (__m128){ u, 0, 0, 0 };
+  float __u = ((struct __mm_load_ss_struct*)__p)->__u;
+  return (__m128){ __u, 0, 0, 0 };
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_load1_ps(const float *p)
+_mm_load1_ps(const float *__p)
 {
   struct __mm_load1_ps_struct {
-    float u;
+    float __u;
   } __attribute__((__packed__, __may_alias__));
-  float u = ((struct __mm_load1_ps_struct*)p)->u;
-  return (__m128){ u, u, u, u };
+  float __u = ((struct __mm_load1_ps_struct*)__p)->__u;
+  return (__m128){ __u, __u, __u, __u };
 }
 
 #define        _mm_load_ps1(p) _mm_load1_ps(p)
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_load_ps(const float *p)
+_mm_load_ps(const float *__p)
 {
-  return *(__m128*)p;
+  return *(__m128*)__p;
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_loadu_ps(const float *p)
+_mm_loadu_ps(const float *__p)
 {
   struct __loadu_ps {
-    __m128 v;
+    __m128 __v;
   } __attribute__((__packed__, __may_alias__));
-  return ((struct __loadu_ps*)p)->v;
+  return ((struct __loadu_ps*)__p)->__v;
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_loadr_ps(const float *p)
+_mm_loadr_ps(const float *__p)
 {
-  __m128 a = _mm_load_ps(p);
-  return __builtin_shufflevector(a, a, 3, 2, 1, 0);
+  __m128 __a = _mm_load_ps(__p);
+  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_set_ss(float w)
+_mm_set_ss(float __w)
 {
-  return (__m128){ w, 0, 0, 0 };
+  return (__m128){ __w, 0, 0, 0 };
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_set1_ps(float w)
+_mm_set1_ps(float __w)
 {
-  return (__m128){ w, w, w, w };
+  return (__m128){ __w, __w, __w, __w };
 }
 
 // Microsoft specific.
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_set_ps1(float w)
+_mm_set_ps1(float __w)
 {
-    return _mm_set1_ps(w);
+    return _mm_set1_ps(__w);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_set_ps(float z, float y, float x, float w)
+_mm_set_ps(float __z, float __y, float __x, float __w)
 {
-  return (__m128){ w, x, y, z };
+  return (__m128){ __w, __x, __y, __z };
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_setr_ps(float z, float y, float x, float w)
+_mm_setr_ps(float __z, float __y, float __x, float __w)
 {
-  return (__m128){ z, y, x, w };
+  return (__m128){ __z, __y, __x, __w };
 }
 
 static __inline__ __m128 __attribute__((__always_inline__))
@@ -604,56 +607,56 @@
 }
 
 static __inline__ void __attribute__((__always_inline__))
-_mm_storeh_pi(__m64 *p, __m128 a)
+_mm_storeh_pi(__m64 *__p, __m128 __a)
 {
-  __builtin_ia32_storehps((__v2si *)p, a);
+  __builtin_ia32_storehps((__v2si *)__p, __a);
 }
 
 static __inline__ void __attribute__((__always_inline__))
-_mm_storel_pi(__m64 *p, __m128 a)
+_mm_storel_pi(__m64 *__p, __m128 __a)
 {
-  __builtin_ia32_storelps((__v2si *)p, a);
+  __builtin_ia32_storelps((__v2si *)__p, __a);
 }
 
 static __inline__ void __attribute__((__always_inline__))
-_mm_store_ss(float *p, __m128 a)
+_mm_store_ss(float *__p, __m128 __a)
 {
   struct __mm_store_ss_struct {
-    float u;
+    float __u;
   } __attribute__((__packed__, __may_alias__));
-  ((struct __mm_store_ss_struct*)p)->u = a[0];
+  ((struct __mm_store_ss_struct*)__p)->__u = __a[0];
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_storeu_ps(float *p, __m128 a)
+_mm_storeu_ps(float *__p, __m128 __a)
 {
-  __builtin_ia32_storeups(p, a);
+  __builtin_ia32_storeups(__p, __a);
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_store1_ps(float *p, __m128 a)
+_mm_store1_ps(float *__p, __m128 __a)
 {
-  a = __builtin_shufflevector(a, a, 0, 0, 0, 0);
-  _mm_storeu_ps(p, a);
+  __a = __builtin_shufflevector(__a, __a, 0, 0, 0, 0);
+  _mm_storeu_ps(__p, __a);
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_store_ps1(float *p, __m128 a)
+_mm_store_ps1(float *__p, __m128 __a)
 {
-    return _mm_store1_ps(p, a);
+    return _mm_store1_ps(__p, __a);
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_store_ps(float *p, __m128 a)
+_mm_store_ps(float *__p, __m128 __a)
 {
-  *(__m128 *)p = a;
+  *(__m128 *)__p = __a;
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_storer_ps(float *p, __m128 a)
+_mm_storer_ps(float *__p, __m128 __a)
 {
-  a = __builtin_shufflevector(a, a, 3, 2, 1, 0);
-  _mm_store_ps(p, a);
+  __a = __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
+  _mm_store_ps(__p, __a);
 }
 
 #define _MM_HINT_T0 3
@@ -667,15 +670,15 @@
 #define _mm_prefetch(a, sel) (__builtin_prefetch((void *)(a), 0, (sel)))
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_stream_pi(__m64 *p, __m64 a)
+_mm_stream_pi(__m64 *__p, __m64 __a)
 {
-  __builtin_ia32_movntq(p, a);
+  __builtin_ia32_movntq(__p, __a);
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_stream_ps(float *p, __m128 a)
+_mm_stream_ps(float *__p, __m128 __a)
 {
-  __builtin_ia32_movntps(p, a);
+  __builtin_ia32_movntps(__p, __a);
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
@@ -685,54 +688,54 @@
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_extract_pi16(__m64 a, int n)
+_mm_extract_pi16(__m64 __a, int __n)
 {
-  __v4hi b = (__v4hi)a;
-  return (unsigned short)b[n & 3];
+  __v4hi __b = (__v4hi)__a;
+  return (unsigned short)__b[__n & 3];
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_insert_pi16(__m64 a, int d, int n)
+_mm_insert_pi16(__m64 __a, int __d, int __n)
 {
-   __v4hi b = (__v4hi)a;
-   b[n & 3] = d;
-   return (__m64)b;
+   __v4hi __b = (__v4hi)__a;
+   __b[__n & 3] = __d;
+   return (__m64)__b;
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_max_pi16(__m64 a, __m64 b)
+_mm_max_pi16(__m64 __a, __m64 __b)
 {
-  return (__m64)__builtin_ia32_pmaxsw((__v4hi)a, (__v4hi)b);
+  return (__m64)__builtin_ia32_pmaxsw((__v4hi)__a, (__v4hi)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_max_pu8(__m64 a, __m64 b)
+_mm_max_pu8(__m64 __a, __m64 __b)
 {
-  return (__m64)__builtin_ia32_pmaxub((__v8qi)a, (__v8qi)b);
+  return (__m64)__builtin_ia32_pmaxub((__v8qi)__a, (__v8qi)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_min_pi16(__m64 a, __m64 b)
+_mm_min_pi16(__m64 __a, __m64 __b)
 {
-  return (__m64)__builtin_ia32_pminsw((__v4hi)a, (__v4hi)b);
+  return (__m64)__builtin_ia32_pminsw((__v4hi)__a, (__v4hi)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_min_pu8(__m64 a, __m64 b)
+_mm_min_pu8(__m64 __a, __m64 __b)
 {
-  return (__m64)__builtin_ia32_pminub((__v8qi)a, (__v8qi)b);
+  return (__m64)__builtin_ia32_pminub((__v8qi)__a, (__v8qi)__b);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_movemask_pi8(__m64 a)
+_mm_movemask_pi8(__m64 __a)
 {
-  return __builtin_ia32_pmovmskb((__v8qi)a);
+  return __builtin_ia32_pmovmskb((__v8qi)__a);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_mulhi_pu16(__m64 a, __m64 b)
+_mm_mulhi_pu16(__m64 __a, __m64 __b)
 {
-  return (__m64)__builtin_ia32_pmulhuw((__v4hi)a, (__v4hi)b);  
+  return (__m64)__builtin_ia32_pmulhuw((__v4hi)__a, (__v4hi)__b);
 }
 
 #define _mm_shuffle_pi16(a, n) __extension__ ({ \
@@ -740,27 +743,27 @@
   (__m64)__builtin_ia32_pshufw((__v4hi)__a, (n)); })
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_maskmove_si64(__m64 d, __m64 n, char *p)
+_mm_maskmove_si64(__m64 __d, __m64 __n, char *__p)
 {
-  __builtin_ia32_maskmovq((__v8qi)d, (__v8qi)n, p);
+  __builtin_ia32_maskmovq((__v8qi)__d, (__v8qi)__n, __p);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_avg_pu8(__m64 a, __m64 b)
+_mm_avg_pu8(__m64 __a, __m64 __b)
 {
-  return (__m64)__builtin_ia32_pavgb((__v8qi)a, (__v8qi)b);
+  return (__m64)__builtin_ia32_pavgb((__v8qi)__a, (__v8qi)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_avg_pu16(__m64 a, __m64 b)
+_mm_avg_pu16(__m64 __a, __m64 __b)
 {
-  return (__m64)__builtin_ia32_pavgw((__v4hi)a, (__v4hi)b);
+  return (__m64)__builtin_ia32_pavgw((__v4hi)__a, (__v4hi)__b);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_sad_pu8(__m64 a, __m64 b)
+_mm_sad_pu8(__m64 __a, __m64 __b)
 {
-  return (__m64)__builtin_ia32_psadbw((__v8qi)a, (__v8qi)b);
+  return (__m64)__builtin_ia32_psadbw((__v8qi)__a, (__v8qi)__b);
 }
 
 static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__))
@@ -770,9 +773,9 @@
 }
 
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_mm_setcsr(unsigned int i)
+_mm_setcsr(unsigned int __i)
 {
-  __builtin_ia32_ldmxcsr(i);
+  __builtin_ia32_ldmxcsr(__i);
 }
 
 #define _mm_shuffle_ps(a, b, mask) __extension__ ({ \
@@ -784,132 +787,132 @@
                                   (((mask) & 0xc0) >> 6) + 4); })
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_unpackhi_ps(__m128 a, __m128 b)
+_mm_unpackhi_ps(__m128 __a, __m128 __b)
 {
-  return __builtin_shufflevector(a, b, 2, 6, 3, 7);
+  return __builtin_shufflevector(__a, __b, 2, 6, 3, 7);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_unpacklo_ps(__m128 a, __m128 b)
+_mm_unpacklo_ps(__m128 __a, __m128 __b)
 {
-  return __builtin_shufflevector(a, b, 0, 4, 1, 5);
+  return __builtin_shufflevector(__a, __b, 0, 4, 1, 5);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_move_ss(__m128 a, __m128 b)
+_mm_move_ss(__m128 __a, __m128 __b)
 {
-  return __builtin_shufflevector(a, b, 4, 1, 2, 3);
+  return __builtin_shufflevector(__a, __b, 4, 1, 2, 3);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_movehl_ps(__m128 a, __m128 b)
+_mm_movehl_ps(__m128 __a, __m128 __b)
 {
-  return __builtin_shufflevector(a, b, 6, 7, 2, 3);
+  return __builtin_shufflevector(__a, __b, 6, 7, 2, 3);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_movelh_ps(__m128 a, __m128 b)
+_mm_movelh_ps(__m128 __a, __m128 __b)
 {
-  return __builtin_shufflevector(a, b, 0, 1, 4, 5);
+  return __builtin_shufflevector(__a, __b, 0, 1, 4, 5);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cvtpi16_ps(__m64 a)
+_mm_cvtpi16_ps(__m64 __a)
 {
-  __m64 b, c;
-  __m128 r;
+  __m64 __b, __c;
+  __m128 __r;
 
-  b = _mm_setzero_si64();
-  b = _mm_cmpgt_pi16(b, a);
-  c = _mm_unpackhi_pi16(a, b);  
-  r = _mm_setzero_ps();
-  r = _mm_cvtpi32_ps(r, c);
-  r = _mm_movelh_ps(r, r);
-  c = _mm_unpacklo_pi16(a, b);  
-  r = _mm_cvtpi32_ps(r, c);
+  __b = _mm_setzero_si64();
+  __b = _mm_cmpgt_pi16(__b, __a);
+  __c = _mm_unpackhi_pi16(__a, __b);
+  __r = _mm_setzero_ps();
+  __r = _mm_cvtpi32_ps(__r, __c);
+  __r = _mm_movelh_ps(__r, __r);
+  __c = _mm_unpacklo_pi16(__a, __b);
+  __r = _mm_cvtpi32_ps(__r, __c);
 
-  return r;
+  return __r;
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cvtpu16_ps(__m64 a)
+_mm_cvtpu16_ps(__m64 __a)
 {
-  __m64 b, c;
-  __m128 r;
+  __m64 __b, __c;
+  __m128 __r;
 
-  b = _mm_setzero_si64();
-  c = _mm_unpackhi_pi16(a, b);  
-  r = _mm_setzero_ps();
-  r = _mm_cvtpi32_ps(r, c);
-  r = _mm_movelh_ps(r, r);
-  c = _mm_unpacklo_pi16(a, b);  
-  r = _mm_cvtpi32_ps(r, c);
+  __b = _mm_setzero_si64();
+  __c = _mm_unpackhi_pi16(__a, __b);
+  __r = _mm_setzero_ps();
+  __r = _mm_cvtpi32_ps(__r, __c);
+  __r = _mm_movelh_ps(__r, __r);
+  __c = _mm_unpacklo_pi16(__a, __b);
+  __r = _mm_cvtpi32_ps(__r, __c);
 
-  return r;
+  return __r;
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cvtpi8_ps(__m64 a)
+_mm_cvtpi8_ps(__m64 __a)
 {
-  __m64 b;
+  __m64 __b;
   
-  b = _mm_setzero_si64();
-  b = _mm_cmpgt_pi8(b, a);
-  b = _mm_unpacklo_pi8(a, b);
+  __b = _mm_setzero_si64();
+  __b = _mm_cmpgt_pi8(__b, __a);
+  __b = _mm_unpacklo_pi8(__a, __b);
 
-  return _mm_cvtpi16_ps(b);
+  return _mm_cvtpi16_ps(__b);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cvtpu8_ps(__m64 a)
+_mm_cvtpu8_ps(__m64 __a)
 {
-  __m64 b;
+  __m64 __b;
   
-  b = _mm_setzero_si64();
-  b = _mm_unpacklo_pi8(a, b);
+  __b = _mm_setzero_si64();
+  __b = _mm_unpacklo_pi8(__a, __b);
 
-  return _mm_cvtpi16_ps(b);
+  return _mm_cvtpi16_ps(__b);
 }
 
 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
-_mm_cvtpi32x2_ps(__m64 a, __m64 b)
+_mm_cvtpi32x2_ps(__m64 __a, __m64 __b)
 {
-  __m128 c;
+  __m128 __c;
   
-  c = _mm_setzero_ps();  
-  c = _mm_cvtpi32_ps(c, b);
-  c = _mm_movelh_ps(c, c);
+  __c = _mm_setzero_ps();
+  __c = _mm_cvtpi32_ps(__c, __b);
+  __c = _mm_movelh_ps(__c, __c);
 
-  return _mm_cvtpi32_ps(c, a);
+  return _mm_cvtpi32_ps(__c, __a);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_cvtps_pi16(__m128 a)
+_mm_cvtps_pi16(__m128 __a)
 {
-  __m64 b, c;
+  __m64 __b, __c;
   
-  b = _mm_cvtps_pi32(a);
-  a = _mm_movehl_ps(a, a);
-  c = _mm_cvtps_pi32(a);
+  __b = _mm_cvtps_pi32(__a);
+  __a = _mm_movehl_ps(__a, __a);
+  __c = _mm_cvtps_pi32(__a);
   
-  return _mm_packs_pi16(b, c);
+  return _mm_packs_pi16(__b, __c);
 }
 
 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
-_mm_cvtps_pi8(__m128 a)
+_mm_cvtps_pi8(__m128 __a)
 {
-  __m64 b, c;
+  __m64 __b, __c;
   
-  b = _mm_cvtps_pi16(a);
-  c = _mm_setzero_si64();
+  __b = _mm_cvtps_pi16(__a);
+  __c = _mm_setzero_si64();
   
-  return _mm_packs_pi16(b, c);
+  return _mm_packs_pi16(__b, __c);
 }
 
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
-_mm_movemask_ps(__m128 a)
+_mm_movemask_ps(__m128 __a)
 {
-  return __builtin_ia32_movmskps(a);
+  return __builtin_ia32_movmskps(__a);
 }
 
 #define _MM_SHUFFLE(z, y, x, w) (((z) << 6) | ((y) << 4) | ((x) << 2) | (w))
diff --git a/renderscript/lib/arm/libRSSupport.so b/renderscript/lib/arm/libRSSupport.so
index da35380..e94d103 100755
--- a/renderscript/lib/arm/libRSSupport.so
+++ b/renderscript/lib/arm/libRSSupport.so
Binary files differ
diff --git a/renderscript/lib/arm/libclcore.bc b/renderscript/lib/arm/libclcore.bc
index 4684d2b..5b2e319 100644
--- a/renderscript/lib/arm/libclcore.bc
+++ b/renderscript/lib/arm/libclcore.bc
Binary files differ
diff --git a/renderscript/lib/arm/librsjni.so b/renderscript/lib/arm/librsjni.so
index a088d59..d3aa1c0 100755
--- a/renderscript/lib/arm/librsjni.so
+++ b/renderscript/lib/arm/librsjni.so
Binary files differ
diff --git a/renderscript/lib/javalib.jar b/renderscript/lib/javalib.jar
index 33585e1..d39b567 100644
--- a/renderscript/lib/javalib.jar
+++ b/renderscript/lib/javalib.jar
Binary files differ
diff --git a/renderscript/lib/mips/libRSSupport.so b/renderscript/lib/mips/libRSSupport.so
index 6bcc15a..3f383e0 100755
--- a/renderscript/lib/mips/libRSSupport.so
+++ b/renderscript/lib/mips/libRSSupport.so
Binary files differ
diff --git a/renderscript/lib/mips/libclcore.bc b/renderscript/lib/mips/libclcore.bc
index 4684d2b..5b2e319 100644
--- a/renderscript/lib/mips/libclcore.bc
+++ b/renderscript/lib/mips/libclcore.bc
Binary files differ
diff --git a/renderscript/lib/x86/libRSSupport.so b/renderscript/lib/x86/libRSSupport.so
index 24d5cc9..f084354 100755
--- a/renderscript/lib/x86/libRSSupport.so
+++ b/renderscript/lib/x86/libRSSupport.so
Binary files differ
diff --git a/renderscript/lib/x86/libclcore.bc b/renderscript/lib/x86/libclcore.bc
index 4684d2b..5b2e319 100644
--- a/renderscript/lib/x86/libclcore.bc
+++ b/renderscript/lib/x86/libclcore.bc
Binary files differ
diff --git a/renderscript/lib/x86/librsjni.so b/renderscript/lib/x86/librsjni.so
index 6138ea2..bc0e9c2 100755
--- a/renderscript/lib/x86/librsjni.so
+++ b/renderscript/lib/x86/librsjni.so
Binary files differ