# HG changeset patch
# User Paper <paper@tflc.us>
# Date 1745872319 14400
# Node ID c6e0df09b86f5dcadbbf4fcbb160d4924735ac75
# Parent  55cadb1fac4b902f407f672c843bc2bfb71ab6e6
*: performance improvements with old GCC, reimplement altivec

diff -r 55cadb1fac4b -r c6e0df09b86f include/vec/impl/altivec.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/include/vec/impl/altivec.h	Mon Apr 28 16:31:59 2025 -0400
@@ -0,0 +1,1137 @@
+/**
+ * vec - a tiny SIMD vector library in C99
+ * 
+ * Copyright (c) 2024-2025 Paper
+ * 
+ * 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.
+**/
+
+/* This file is automatically generated! Do not edit it directly!
+ * Edit the code that generates it in utils/gengcc.c  --paper */
+
+#ifndef VEC_IMPL_PPC_ALTIVEC_H_
+#define VEC_IMPL_PPC_ALTIVEC_H_
+
+
+
+
+/* vuint8x16 */
+
+#ifdef vec_splats
+#ifndef VINT8x16_SPLAT_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_splat(vec_int8 x)
+{
+	vint8x16 vec;
+	vec.altivec = vec_splats(x);
+	return vec;
+}
+# define VINT8x16_SPLAT_DEFINED
+#endif
+#endif
+#ifndef VINT8x16_LOAD_ALIGNED_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_load_aligned(const vec_int8 x[16])
+{
+	vint8x16 vec;
+	vec.altivec = vec_ld(0, x);
+	return vec;
+}
+# define VINT8x16_LOAD_ALIGNED_DEFINED
+#endif
+#ifndef VINT8x16_LOAD_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_load(const vec_int8 x[16])
+{
+	vint8x16 vec;
+	vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x));
+	return vec;
+}
+# define VINT8x16_LOAD_DEFINED
+#endif
+#ifndef VINT8x16_STORE_ALIGNED_DEFINED
+VEC_FUNC_IMPL void vint8x16_store_aligned(vint8x16 vec, vec_int8 arr[16])
+{
+	vec_st(vec.altivec, 0, arr);
+}
+# define VINT8x16_STORE_ALIGNED_DEFINED
+#endif
+#ifndef VINT8x16_STORE_DEFINED
+VEC_FUNC_IMPL void vint8x16_store(vint8x16 vec, vec_int8 arr[16])
+{
+	memcpy(arr, &vec, sizeof(vec));
+}
+# define VINT8x16_STORE_DEFINED
+#endif
+#ifndef VINT8x16_ADD_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_add(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_add(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_ADD_DEFINED
+#endif
+#ifndef VINT8x16_SUB_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_sub(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_sub(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_SUB_DEFINED
+#endif
+#ifdef vec_mul
+#ifndef VINT8x16_MUL_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_mul(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_mul(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_MUL_DEFINED
+#endif
+#endif
+#ifndef VINT8x16_AND_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_and(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_and(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_AND_DEFINED
+#endif
+#ifndef VINT8x16_OR_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_or(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_or(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_OR_DEFINED
+#endif
+#ifndef VINT8x16_XOR_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_xor(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_xor(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_XOR_DEFINED
+#endif
+#ifndef VINT8x16_CMPLT_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_cmplt(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_cmplt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_CMPLT_DEFINED
+#endif
+#ifndef VINT8x16_CMPEQ_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_cmpeq(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_cmpeq(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_CMPEQ_DEFINED
+#endif
+#ifndef VINT8x16_CMPGT_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_cmpgt(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_cmpgt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_CMPGT_DEFINED
+#endif
+#ifndef VINT8x16_MIN_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_min(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_avg(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_MIN_DEFINED
+#endif
+#ifndef VINT8x16_MAX_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_max(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_sl(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_MAX_DEFINED
+#endif
+#ifndef VINT8x16_AVG_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_avg(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_AVG_DEFINED
+#endif
+#ifndef VINT8x16_LSHIFT_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_lshift(vint8x16 vec1, vuint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_min(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_LSHIFT_DEFINED
+#endif
+#ifndef VINT8x16_LRSHIFT_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_lrshift(vint8x16 vec1, vuint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_max(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_LRSHIFT_DEFINED
+#endif
+#ifndef VINT8x16_RSHIFT_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_rshift(vint8x16 vec1, vuint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = vec_sra(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_RSHIFT_DEFINED
+#endif
+
+
+/* vint8x16 */
+
+#ifdef vec_splats
+#ifndef VUINT8x16_SPLAT_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_splat(vec_uint8 x)
+{
+	vuint8x16 vec;
+	vec.altivec = vec_splats(x);
+	return vec;
+}
+# define VUINT8x16_SPLAT_DEFINED
+#endif
+#endif
+#ifndef VUINT8x16_LOAD_ALIGNED_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_load_aligned(const vec_uint8 x[16])
+{
+	vuint8x16 vec;
+	vec.altivec = vec_ld(0, x);
+	return vec;
+}
+# define VUINT8x16_LOAD_ALIGNED_DEFINED
+#endif
+#ifndef VUINT8x16_LOAD_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_load(const vec_uint8 x[16])
+{
+	vuint8x16 vec;
+	vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x));
+	return vec;
+}
+# define VUINT8x16_LOAD_DEFINED
+#endif
+#ifndef VUINT8x16_STORE_ALIGNED_DEFINED
+VEC_FUNC_IMPL void vuint8x16_store_aligned(vuint8x16 vec, vec_uint8 arr[16])
+{
+	vec_st(vec.altivec, 0, arr);
+}
+# define VUINT8x16_STORE_ALIGNED_DEFINED
+#endif
+#ifndef VUINT8x16_STORE_DEFINED
+VEC_FUNC_IMPL void vuint8x16_store(vuint8x16 vec, vec_uint8 arr[16])
+{
+	memcpy(arr, &vec, sizeof(vec));
+}
+# define VUINT8x16_STORE_DEFINED
+#endif
+#ifndef VUINT8x16_ADD_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_add(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_add(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_ADD_DEFINED
+#endif
+#ifndef VUINT8x16_SUB_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_sub(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_sub(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_SUB_DEFINED
+#endif
+#ifdef vec_mul
+#ifndef VUINT8x16_MUL_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_mul(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_mul(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_MUL_DEFINED
+#endif
+#endif
+#ifndef VUINT8x16_AND_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_and(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_and(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_AND_DEFINED
+#endif
+#ifndef VUINT8x16_OR_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_or(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_or(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_OR_DEFINED
+#endif
+#ifndef VUINT8x16_XOR_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_xor(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_xor(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_XOR_DEFINED
+#endif
+#ifndef VUINT8x16_CMPLT_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_cmplt(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_cmplt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_CMPLT_DEFINED
+#endif
+#ifndef VUINT8x16_CMPEQ_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_cmpeq(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_cmpeq(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_CMPEQ_DEFINED
+#endif
+#ifndef VUINT8x16_CMPGT_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_cmpgt(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_cmpgt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_CMPGT_DEFINED
+#endif
+#ifndef VUINT8x16_MIN_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_min(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_avg(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_MIN_DEFINED
+#endif
+#ifndef VUINT8x16_MAX_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_max(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_sl(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_MAX_DEFINED
+#endif
+#ifndef VUINT8x16_AVG_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_avg(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_AVG_DEFINED
+#endif
+#ifndef VUINT8x16_LSHIFT_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_lshift(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_min(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_LSHIFT_DEFINED
+#endif
+#ifndef VUINT8x16_LRSHIFT_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_lrshift(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_max(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_LRSHIFT_DEFINED
+#endif
+#ifndef VUINT8x16_RSHIFT_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_rshift(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_RSHIFT_DEFINED
+#endif
+
+
+/* vuint16x8 */
+
+#ifdef vec_splats
+#ifndef VINT16x8_SPLAT_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_splat(vec_int16 x)
+{
+	vint16x8 vec;
+	vec.altivec = vec_splats(x);
+	return vec;
+}
+# define VINT16x8_SPLAT_DEFINED
+#endif
+#endif
+#ifndef VINT16x8_LOAD_ALIGNED_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_load_aligned(const vec_int16 x[8])
+{
+	vint16x8 vec;
+	vec.altivec = vec_ld(0, x);
+	return vec;
+}
+# define VINT16x8_LOAD_ALIGNED_DEFINED
+#endif
+#ifndef VINT16x8_LOAD_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_load(const vec_int16 x[8])
+{
+	vint16x8 vec;
+	vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x));
+	return vec;
+}
+# define VINT16x8_LOAD_DEFINED
+#endif
+#ifndef VINT16x8_STORE_ALIGNED_DEFINED
+VEC_FUNC_IMPL void vint16x8_store_aligned(vint16x8 vec, vec_int16 arr[8])
+{
+	vec_st(vec.altivec, 0, arr);
+}
+# define VINT16x8_STORE_ALIGNED_DEFINED
+#endif
+#ifndef VINT16x8_STORE_DEFINED
+VEC_FUNC_IMPL void vint16x8_store(vint16x8 vec, vec_int16 arr[8])
+{
+	memcpy(arr, &vec, sizeof(vec));
+}
+# define VINT16x8_STORE_DEFINED
+#endif
+#ifndef VINT16x8_ADD_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_add(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_add(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_ADD_DEFINED
+#endif
+#ifndef VINT16x8_SUB_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_sub(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_sub(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_SUB_DEFINED
+#endif
+#ifdef vec_mul
+#ifndef VINT16x8_MUL_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_mul(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_mul(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_MUL_DEFINED
+#endif
+#endif
+#ifndef VINT16x8_AND_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_and(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_and(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_AND_DEFINED
+#endif
+#ifndef VINT16x8_OR_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_or(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_or(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_OR_DEFINED
+#endif
+#ifndef VINT16x8_XOR_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_xor(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_xor(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_XOR_DEFINED
+#endif
+#ifndef VINT16x8_CMPLT_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_cmplt(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_cmplt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_CMPLT_DEFINED
+#endif
+#ifndef VINT16x8_CMPEQ_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_cmpeq(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_cmpeq(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_CMPEQ_DEFINED
+#endif
+#ifndef VINT16x8_CMPGT_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_cmpgt(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_cmpgt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_CMPGT_DEFINED
+#endif
+#ifndef VINT16x8_MIN_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_min(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_avg(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_MIN_DEFINED
+#endif
+#ifndef VINT16x8_MAX_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_max(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_sl(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_MAX_DEFINED
+#endif
+#ifndef VINT16x8_AVG_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_avg(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_AVG_DEFINED
+#endif
+#ifndef VINT16x8_LSHIFT_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_lshift(vint16x8 vec1, vuint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_min(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_LSHIFT_DEFINED
+#endif
+#ifndef VINT16x8_LRSHIFT_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_lrshift(vint16x8 vec1, vuint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_max(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_LRSHIFT_DEFINED
+#endif
+#ifndef VINT16x8_RSHIFT_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_rshift(vint16x8 vec1, vuint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = vec_sra(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_RSHIFT_DEFINED
+#endif
+
+
+/* vint16x8 */
+
+#ifdef vec_splats
+#ifndef VUINT16x8_SPLAT_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_splat(vec_uint16 x)
+{
+	vuint16x8 vec;
+	vec.altivec = vec_splats(x);
+	return vec;
+}
+# define VUINT16x8_SPLAT_DEFINED
+#endif
+#endif
+#ifndef VUINT16x8_LOAD_ALIGNED_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_load_aligned(const vec_uint16 x[8])
+{
+	vuint16x8 vec;
+	vec.altivec = vec_ld(0, x);
+	return vec;
+}
+# define VUINT16x8_LOAD_ALIGNED_DEFINED
+#endif
+#ifndef VUINT16x8_LOAD_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_load(const vec_uint16 x[8])
+{
+	vuint16x8 vec;
+	vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x));
+	return vec;
+}
+# define VUINT16x8_LOAD_DEFINED
+#endif
+#ifndef VUINT16x8_STORE_ALIGNED_DEFINED
+VEC_FUNC_IMPL void vuint16x8_store_aligned(vuint16x8 vec, vec_uint16 arr[8])
+{
+	vec_st(vec.altivec, 0, arr);
+}
+# define VUINT16x8_STORE_ALIGNED_DEFINED
+#endif
+#ifndef VUINT16x8_STORE_DEFINED
+VEC_FUNC_IMPL void vuint16x8_store(vuint16x8 vec, vec_uint16 arr[8])
+{
+	memcpy(arr, &vec, sizeof(vec));
+}
+# define VUINT16x8_STORE_DEFINED
+#endif
+#ifndef VUINT16x8_ADD_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_add(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_add(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_ADD_DEFINED
+#endif
+#ifndef VUINT16x8_SUB_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_sub(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_sub(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_SUB_DEFINED
+#endif
+#ifdef vec_mul
+#ifndef VUINT16x8_MUL_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_mul(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_mul(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_MUL_DEFINED
+#endif
+#endif
+#ifndef VUINT16x8_AND_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_and(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_and(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_AND_DEFINED
+#endif
+#ifndef VUINT16x8_OR_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_or(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_or(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_OR_DEFINED
+#endif
+#ifndef VUINT16x8_XOR_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_xor(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_xor(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_XOR_DEFINED
+#endif
+#ifndef VUINT16x8_CMPLT_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_cmplt(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_cmplt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_CMPLT_DEFINED
+#endif
+#ifndef VUINT16x8_CMPEQ_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_cmpeq(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_cmpeq(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_CMPEQ_DEFINED
+#endif
+#ifndef VUINT16x8_CMPGT_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_cmpgt(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_cmpgt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_CMPGT_DEFINED
+#endif
+#ifndef VUINT16x8_MIN_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_min(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_avg(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_MIN_DEFINED
+#endif
+#ifndef VUINT16x8_MAX_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_max(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_sl(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_MAX_DEFINED
+#endif
+#ifndef VUINT16x8_AVG_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_avg(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_AVG_DEFINED
+#endif
+#ifndef VUINT16x8_LSHIFT_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_lshift(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_min(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_LSHIFT_DEFINED
+#endif
+#ifndef VUINT16x8_LRSHIFT_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_lrshift(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_max(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_LRSHIFT_DEFINED
+#endif
+#ifndef VUINT16x8_RSHIFT_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_rshift(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_RSHIFT_DEFINED
+#endif
+
+
+/* vuint32x4 */
+
+#ifdef vec_splats
+#ifndef VINT32x4_SPLAT_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_splat(vec_int32 x)
+{
+	vint32x4 vec;
+	vec.altivec = vec_splats(x);
+	return vec;
+}
+# define VINT32x4_SPLAT_DEFINED
+#endif
+#endif
+#ifndef VINT32x4_LOAD_ALIGNED_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_load_aligned(const vec_int32 x[4])
+{
+	vint32x4 vec;
+	vec.altivec = vec_ld(0, x);
+	return vec;
+}
+# define VINT32x4_LOAD_ALIGNED_DEFINED
+#endif
+#ifndef VINT32x4_LOAD_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_load(const vec_int32 x[4])
+{
+	vint32x4 vec;
+	vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x));
+	return vec;
+}
+# define VINT32x4_LOAD_DEFINED
+#endif
+#ifndef VINT32x4_STORE_ALIGNED_DEFINED
+VEC_FUNC_IMPL void vint32x4_store_aligned(vint32x4 vec, vec_int32 arr[4])
+{
+	vec_st(vec.altivec, 0, arr);
+}
+# define VINT32x4_STORE_ALIGNED_DEFINED
+#endif
+#ifndef VINT32x4_STORE_DEFINED
+VEC_FUNC_IMPL void vint32x4_store(vint32x4 vec, vec_int32 arr[4])
+{
+	memcpy(arr, &vec, sizeof(vec));
+}
+# define VINT32x4_STORE_DEFINED
+#endif
+#ifndef VINT32x4_ADD_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_add(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_add(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_ADD_DEFINED
+#endif
+#ifndef VINT32x4_SUB_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_sub(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_sub(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_SUB_DEFINED
+#endif
+#ifdef vec_mul
+#ifndef VINT32x4_MUL_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_mul(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_mul(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_MUL_DEFINED
+#endif
+#endif
+#ifndef VINT32x4_AND_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_and(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_and(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_AND_DEFINED
+#endif
+#ifndef VINT32x4_OR_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_or(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_or(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_OR_DEFINED
+#endif
+#ifndef VINT32x4_XOR_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_xor(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_xor(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_XOR_DEFINED
+#endif
+#ifndef VINT32x4_CMPLT_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_cmplt(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_cmplt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_CMPLT_DEFINED
+#endif
+#ifndef VINT32x4_CMPEQ_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_cmpeq(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_cmpeq(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_CMPEQ_DEFINED
+#endif
+#ifndef VINT32x4_CMPGT_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_cmpgt(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_cmpgt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_CMPGT_DEFINED
+#endif
+#ifndef VINT32x4_MIN_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_min(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_avg(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_MIN_DEFINED
+#endif
+#ifndef VINT32x4_MAX_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_max(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_sl(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_MAX_DEFINED
+#endif
+#ifndef VINT32x4_AVG_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_avg(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_AVG_DEFINED
+#endif
+#ifndef VINT32x4_LSHIFT_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_lshift(vint32x4 vec1, vuint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_min(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_LSHIFT_DEFINED
+#endif
+#ifndef VINT32x4_LRSHIFT_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_lrshift(vint32x4 vec1, vuint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_max(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_LRSHIFT_DEFINED
+#endif
+#ifndef VINT32x4_RSHIFT_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_rshift(vint32x4 vec1, vuint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = vec_sra(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_RSHIFT_DEFINED
+#endif
+
+
+/* vint32x4 */
+
+#ifdef vec_splats
+#ifndef VUINT32x4_SPLAT_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_splat(vec_uint32 x)
+{
+	vuint32x4 vec;
+	vec.altivec = vec_splats(x);
+	return vec;
+}
+# define VUINT32x4_SPLAT_DEFINED
+#endif
+#endif
+#ifndef VUINT32x4_LOAD_ALIGNED_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_load_aligned(const vec_uint32 x[4])
+{
+	vuint32x4 vec;
+	vec.altivec = vec_ld(0, x);
+	return vec;
+}
+# define VUINT32x4_LOAD_ALIGNED_DEFINED
+#endif
+#ifndef VUINT32x4_LOAD_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_load(const vec_uint32 x[4])
+{
+	vuint32x4 vec;
+	vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x));
+	return vec;
+}
+# define VUINT32x4_LOAD_DEFINED
+#endif
+#ifndef VUINT32x4_STORE_ALIGNED_DEFINED
+VEC_FUNC_IMPL void vuint32x4_store_aligned(vuint32x4 vec, vec_uint32 arr[4])
+{
+	vec_st(vec.altivec, 0, arr);
+}
+# define VUINT32x4_STORE_ALIGNED_DEFINED
+#endif
+#ifndef VUINT32x4_STORE_DEFINED
+VEC_FUNC_IMPL void vuint32x4_store(vuint32x4 vec, vec_uint32 arr[4])
+{
+	memcpy(arr, &vec, sizeof(vec));
+}
+# define VUINT32x4_STORE_DEFINED
+#endif
+#ifndef VUINT32x4_ADD_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_add(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_add(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_ADD_DEFINED
+#endif
+#ifndef VUINT32x4_SUB_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_sub(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_sub(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_SUB_DEFINED
+#endif
+#ifdef vec_mul
+#ifndef VUINT32x4_MUL_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_mul(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_mul(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_MUL_DEFINED
+#endif
+#endif
+#ifndef VUINT32x4_AND_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_and(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_and(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_AND_DEFINED
+#endif
+#ifndef VUINT32x4_OR_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_or(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_or(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_OR_DEFINED
+#endif
+#ifndef VUINT32x4_XOR_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_xor(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_xor(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_XOR_DEFINED
+#endif
+#ifndef VUINT32x4_CMPLT_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_cmplt(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_cmplt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_CMPLT_DEFINED
+#endif
+#ifndef VUINT32x4_CMPEQ_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_cmpeq(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_cmpeq(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_CMPEQ_DEFINED
+#endif
+#ifndef VUINT32x4_CMPGT_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_cmpgt(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_cmpgt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_CMPGT_DEFINED
+#endif
+#ifndef VUINT32x4_MIN_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_min(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_avg(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_MIN_DEFINED
+#endif
+#ifndef VUINT32x4_MAX_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_max(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_sl(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_MAX_DEFINED
+#endif
+#ifndef VUINT32x4_AVG_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_avg(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_AVG_DEFINED
+#endif
+#ifndef VUINT32x4_LSHIFT_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_lshift(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_min(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_LSHIFT_DEFINED
+#endif
+#ifndef VUINT32x4_LRSHIFT_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_lrshift(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_max(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_LRSHIFT_DEFINED
+#endif
+#ifndef VUINT32x4_RSHIFT_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_rshift(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_RSHIFT_DEFINED
+#endif
+#endif /* VEC_IMPL_PPC_ALTIVEC_H_ */
+
diff -r 55cadb1fac4b -r c6e0df09b86f include/vec/impl/double.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/include/vec/impl/double.h	Mon Apr 28 16:31:59 2025 -0400
@@ -0,0 +1,3721 @@
+/**
+ * vec - a tiny SIMD vector library in C99
+ * 
+ * Copyright (c) 2024-2025 Paper
+ * 
+ * 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.
+**/
+
+/* This file is automatically generated! Do not edit it directly!
+ * Edit the code that generates it in utils/gengeneric.c  --paper */
+
+#ifndef VEC_IMPL_DOUBLE_H_
+#define VEC_IMPL_DOUBLE_H_
+
+#define VEC_DOUBLE_SPLAT(sign, bits, size, halfsize) \
+	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_splat(vec_##sign##int##bits x) \
+	{ \
+		v##sign##int##bits##x##size vec; \
+	\
+		vec.generic[0] = v##sign##int##bits##x##halfsize##_splat(x); \
+		vec.generic[1] = v##sign##int##bits##x##halfsize##_splat(x); \
+	\
+		return vec; \
+	}
+
+#define VEC_DOUBLE_LOAD_EX(name, sign, bits, size, halfsize) \
+	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_##name(const vec_##sign##int##bits x[size]) \
+	{ \
+		v##sign##int##bits##x##size vec; \
+	\
+		vec.generic[0] = v##sign##int##bits##x##halfsize##_##name(x); \
+		vec.generic[1] = v##sign##int##bits##x##halfsize##_##name(x + halfsize); \
+	\
+		return vec; \
+	}
+
+#define VEC_DOUBLE_LOAD(sign, bits, size, halfsize) VEC_DOUBLE_LOAD_EX(load, sign, bits, size, halfsize)
+#define VEC_DOUBLE_LOAD_ALIGNED(sign, bits, size, halfsize) VEC_DOUBLE_LOAD_EX(load_aligned, sign, bits, size, halfsize)
+
+#define VEC_DOUBLE_STORE_EX(name, sign, bits, size, halfsize) \
+	VEC_FUNC_IMPL void v##sign##int##bits##x##size##_##name(v##sign##int##bits##x##size vec, vec_##sign##int##bits x[size]) \
+	{ \
+		v##sign##int##bits##x##halfsize##_##name(vec.generic[0], x); \
+		v##sign##int##bits##x##halfsize##_##name(vec.generic[1], x + halfsize); \
+	}
+
+#define VEC_DOUBLE_STORE(sign, bits, size, halfsize) VEC_DOUBLE_STORE_EX(store, sign, bits, size, halfsize)
+#define VEC_DOUBLE_STORE_ALIGNED(sign, bits, size, halfsize) VEC_DOUBLE_STORE_EX(store_aligned, sign, bits, size, halfsize)
+
+#define VEC_DOUBLE_OP(name, sign, bits, size, halfsize, secondsign) \
+	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_##name(v##sign##int##bits##x##size vec1, v##secondsign##int##bits##x##size vec2) \
+	{ \
+		vec1.generic[0] = v##sign##int##bits##x##halfsize##_##name(vec1.generic[0], vec2.generic[0]); \
+		vec1.generic[1] = v##sign##int##bits##x##halfsize##_##name(vec1.generic[1], vec2.generic[1]); \
+	\
+		return vec1; \
+	}
+
+#define VEC_DOUBLE_ADD(sign, bits, size, halfsize) VEC_DOUBLE_OP(add, sign, bits, size, halfsize, sign)
+#define VEC_DOUBLE_SUB(sign, bits, size, halfsize) VEC_DOUBLE_OP(sub, sign, bits, size, halfsize, sign)
+#define VEC_DOUBLE_MUL(sign, bits, size, halfsize) VEC_DOUBLE_OP(mul, sign, bits, size, halfsize, sign)
+#define VEC_DOUBLE_DIV(sign, bits, size, halfsize) VEC_DOUBLE_OP(div, sign, bits, size, halfsize, sign)
+#define VEC_DOUBLE_MOD(sign, bits, size, halfsize) VEC_DOUBLE_OP(mod, sign, bits, size, halfsize, sign)
+#define VEC_DOUBLE_AVG(sign, bits, size, halfsize) VEC_DOUBLE_OP(avg, sign, bits, size, halfsize, sign)
+#define VEC_DOUBLE_LSHIFT(sign, bits, size, halfsize) VEC_DOUBLE_OP(lshift, sign, bits, size, halfsize, u)
+#define VEC_DOUBLE_RSHIFT(sign, bits, size, halfsize) VEC_DOUBLE_OP(rshift, sign, bits, size, halfsize, u)
+#define VEC_DOUBLE_LRSHIFT(sign, bits, size, halfsize) VEC_DOUBLE_OP(lrshift, sign, bits, size, halfsize, u)
+#define VEC_DOUBLE_AND(sign, bits, size, halfsize) VEC_DOUBLE_OP(and, sign, bits, size, halfsize, sign)
+#define VEC_DOUBLE_OR(sign, bits, size, halfsize) VEC_DOUBLE_OP(or, sign, bits, size, halfsize, sign)
+#define VEC_DOUBLE_XOR(sign, bits, size, halfsize) VEC_DOUBLE_OP(xor, sign, bits, size, halfsize, sign)
+#define VEC_DOUBLE_MIN(sign, bits, size, halfsize) VEC_DOUBLE_OP(min, sign, bits, size, halfsize, sign)
+#define VEC_DOUBLE_MAX(sign, bits, size, halfsize) VEC_DOUBLE_OP(max, sign, bits, size, halfsize, sign)
+#define VEC_DOUBLE_CMPLT(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmplt, sign, bits, size, halfsize, sign)
+#define VEC_DOUBLE_CMPLE(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmple, sign, bits, size, halfsize, sign)
+#define VEC_DOUBLE_CMPEQ(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmpeq, sign, bits, size, halfsize, sign)
+#define VEC_DOUBLE_CMPGE(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmpge, sign, bits, size, halfsize, sign)
+#define VEC_DOUBLE_CMPGT(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmpgt, sign, bits, size, halfsize, sign)
+
+#define VEC_DOUBLE_NOT(sign, bits, size, halfsize) \
+	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_not(v##sign##int##bits##x##size vec) \
+	{ \
+		vec.generic[0] = v##sign##int##bits##x##halfsize##_not(vec.generic[0]); \
+		vec.generic[1] = v##sign##int##bits##x##halfsize##_not(vec.generic[1]); \
+	\
+		return vec; \
+	}
+
+#endif /* VEC_IMPL_DOUBLE_H_ */ 
+
+/* ------------------------------------------------------------------------ */
+/* PREPROCESSOR HELL INCOMING */
+
+
+
+/* vuint8x4 */
+
+#if !defined(VINT8x4_SPLAT_DEFINED) && defined(VINT8x2_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(/* nothing */, 8, 4, 2)
+# define VINT8x4_SPLAT_DEFINED
+#endif
+
+#if !defined(VINT8x4_LOAD_ALIGNED_DEFINED) && defined(VINT8x2_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 8, 4, 2)
+# define VINT8x4_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT8x4_LOAD_DEFINED) && defined(VINT8x2_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(/* nothing */, 8, 4, 2)
+# define VINT8x4_LOAD_DEFINED
+#endif
+
+#if !defined(VINT8x4_STORE_ALIGNED_DEFINED) && defined(VINT8x2_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 8, 4, 2)
+# define VINT8x4_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT8x4_STORE_DEFINED) && defined(VINT8x2_STORE_DEFINED)
+VEC_DOUBLE_STORE(/* nothing */, 8, 4, 2)
+# define VINT8x4_STORE_DEFINED
+#endif
+
+#if !defined(VINT8x4_ADD_DEFINED) && defined(VINT8x2_ADD_DEFINED)
+VEC_DOUBLE_ADD(/* nothing */, 8, 4, 2)
+# define VINT8x4_ADD_DEFINED
+#endif
+
+#if !defined(VINT8x4_SUB_DEFINED) && defined(VINT8x2_SUB_DEFINED)
+VEC_DOUBLE_SUB(/* nothing */, 8, 4, 2)
+# define VINT8x4_SUB_DEFINED
+#endif
+
+#if !defined(VINT8x4_MUL_DEFINED) && defined(VINT8x2_MUL_DEFINED)
+VEC_DOUBLE_MUL(/* nothing */, 8, 4, 2)
+# define VINT8x4_MUL_DEFINED
+#endif
+
+#if !defined(VINT8x4_DIV_DEFINED) && defined(VINT8x2_DIV_DEFINED)
+VEC_DOUBLE_DIV(/* nothing */, 8, 4, 2)
+# define VINT8x4_DIV_DEFINED
+#endif
+
+#if !defined(VINT8x4_MOD_DEFINED) && defined(VINT8x2_MOD_DEFINED)
+VEC_DOUBLE_MOD(/* nothing */, 8, 4, 2)
+# define VINT8x4_MOD_DEFINED
+#endif
+
+#if !defined(VINT8x4_AVG_DEFINED) && defined(VINT8x2_AVG_DEFINED)
+VEC_DOUBLE_AVG(/* nothing */, 8, 4, 2)
+# define VINT8x4_AVG_DEFINED
+#endif
+
+#if !defined(VINT8x4_AND_DEFINED) && defined(VINT8x2_AND_DEFINED)
+VEC_DOUBLE_AND(/* nothing */, 8, 4, 2)
+# define VINT8x4_AND_DEFINED
+#endif
+
+#if !defined(VINT8x4_OR_DEFINED) && defined(VINT8x2_OR_DEFINED)
+VEC_DOUBLE_OR(/* nothing */, 8, 4, 2)
+# define VINT8x4_OR_DEFINED
+#endif
+
+#if !defined(VINT8x4_XOR_DEFINED) && defined(VINT8x2_XOR_DEFINED)
+VEC_DOUBLE_XOR(/* nothing */, 8, 4, 2)
+# define VINT8x4_XOR_DEFINED
+#endif
+
+#if !defined(VINT8x4_NOT_DEFINED) && defined(VINT8x2_NOT_DEFINED)
+VEC_DOUBLE_NOT(/* nothing */, 8, 4, 2)
+# define VINT8x4_NOT_DEFINED
+#endif
+
+#if !defined(VINT8x4_CMPLT_DEFINED) && defined(VINT8x2_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(/* nothing */, 8, 4, 2)
+# define VINT8x4_CMPLT_DEFINED
+#endif
+
+#if !defined(VINT8x4_CMPEQ_DEFINED) && defined(VINT8x2_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(/* nothing */, 8, 4, 2)
+# define VINT8x4_CMPEQ_DEFINED
+#endif
+
+#if !defined(VINT8x4_CMPGT_DEFINED) && defined(VINT8x2_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(/* nothing */, 8, 4, 2)
+# define VINT8x4_CMPGT_DEFINED
+#endif
+
+#if !defined(VINT8x4_CMPLE_DEFINED) && defined(VINT8x2_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(/* nothing */, 8, 4, 2)
+# define VINT8x4_CMPLE_DEFINED
+#endif
+
+#if !defined(VINT8x4_CMPGE_DEFINED) && defined(VINT8x2_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(/* nothing */, 8, 4, 2)
+# define VINT8x4_CMPGE_DEFINED
+#endif
+
+#if !defined(VINT8x4_MIN_DEFINED) && defined(VINT8x2_MIN_DEFINED)
+VEC_DOUBLE_MIN(/* nothing */, 8, 4, 2)
+# define VINT8x4_MIN_DEFINED
+#endif
+
+#if !defined(VINT8x4_MAX_DEFINED) && defined(VINT8x2_MAX_DEFINED)
+VEC_DOUBLE_MAX(/* nothing */, 8, 4, 2)
+# define VINT8x4_MAX_DEFINED
+#endif
+
+#if !defined(VINT8x4_RSHIFT_DEFINED) && defined(VINT8x2_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(/* nothing */, 8, 4, 2)
+# define VINT8x4_RSHIFT_DEFINED
+#endif
+
+#if !defined(VINT8x4_LRSHIFT_DEFINED) && defined(VINT8x2_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(/* nothing */, 8, 4, 2)
+# define VINT8x4_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VINT8x4_LSHIFT_DEFINED) && defined(VINT8x2_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(/* nothing */, 8, 4, 2)
+# define VINT8x4_LSHIFT_DEFINED
+#endif
+
+
+
+/* vint8x4 */
+
+#if !defined(VUINT8x4_SPLAT_DEFINED) && defined(VUINT8x2_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(u, 8, 4, 2)
+# define VUINT8x4_SPLAT_DEFINED
+#endif
+
+#if !defined(VUINT8x4_LOAD_ALIGNED_DEFINED) && defined(VUINT8x2_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(u, 8, 4, 2)
+# define VUINT8x4_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT8x4_LOAD_DEFINED) && defined(VUINT8x2_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(u, 8, 4, 2)
+# define VUINT8x4_LOAD_DEFINED
+#endif
+
+#if !defined(VUINT8x4_STORE_ALIGNED_DEFINED) && defined(VUINT8x2_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(u, 8, 4, 2)
+# define VUINT8x4_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT8x4_STORE_DEFINED) && defined(VUINT8x2_STORE_DEFINED)
+VEC_DOUBLE_STORE(u, 8, 4, 2)
+# define VUINT8x4_STORE_DEFINED
+#endif
+
+#if !defined(VUINT8x4_ADD_DEFINED) && defined(VUINT8x2_ADD_DEFINED)
+VEC_DOUBLE_ADD(u, 8, 4, 2)
+# define VUINT8x4_ADD_DEFINED
+#endif
+
+#if !defined(VUINT8x4_SUB_DEFINED) && defined(VUINT8x2_SUB_DEFINED)
+VEC_DOUBLE_SUB(u, 8, 4, 2)
+# define VUINT8x4_SUB_DEFINED
+#endif
+
+#if !defined(VUINT8x4_MUL_DEFINED) && defined(VUINT8x2_MUL_DEFINED)
+VEC_DOUBLE_MUL(u, 8, 4, 2)
+# define VUINT8x4_MUL_DEFINED
+#endif
+
+#if !defined(VUINT8x4_DIV_DEFINED) && defined(VUINT8x2_DIV_DEFINED)
+VEC_DOUBLE_DIV(u, 8, 4, 2)
+# define VUINT8x4_DIV_DEFINED
+#endif
+
+#if !defined(VUINT8x4_MOD_DEFINED) && defined(VUINT8x2_MOD_DEFINED)
+VEC_DOUBLE_MOD(u, 8, 4, 2)
+# define VUINT8x4_MOD_DEFINED
+#endif
+
+#if !defined(VUINT8x4_AVG_DEFINED) && defined(VUINT8x2_AVG_DEFINED)
+VEC_DOUBLE_AVG(u, 8, 4, 2)
+# define VUINT8x4_AVG_DEFINED
+#endif
+
+#if !defined(VUINT8x4_AND_DEFINED) && defined(VUINT8x2_AND_DEFINED)
+VEC_DOUBLE_AND(u, 8, 4, 2)
+# define VUINT8x4_AND_DEFINED
+#endif
+
+#if !defined(VUINT8x4_OR_DEFINED) && defined(VUINT8x2_OR_DEFINED)
+VEC_DOUBLE_OR(u, 8, 4, 2)
+# define VUINT8x4_OR_DEFINED
+#endif
+
+#if !defined(VUINT8x4_XOR_DEFINED) && defined(VUINT8x2_XOR_DEFINED)
+VEC_DOUBLE_XOR(u, 8, 4, 2)
+# define VUINT8x4_XOR_DEFINED
+#endif
+
+#if !defined(VUINT8x4_NOT_DEFINED) && defined(VUINT8x2_NOT_DEFINED)
+VEC_DOUBLE_NOT(u, 8, 4, 2)
+# define VUINT8x4_NOT_DEFINED
+#endif
+
+#if !defined(VUINT8x4_CMPLT_DEFINED) && defined(VUINT8x2_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(u, 8, 4, 2)
+# define VUINT8x4_CMPLT_DEFINED
+#endif
+
+#if !defined(VUINT8x4_CMPEQ_DEFINED) && defined(VUINT8x2_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(u, 8, 4, 2)
+# define VUINT8x4_CMPEQ_DEFINED
+#endif
+
+#if !defined(VUINT8x4_CMPGT_DEFINED) && defined(VUINT8x2_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(u, 8, 4, 2)
+# define VUINT8x4_CMPGT_DEFINED
+#endif
+
+#if !defined(VUINT8x4_CMPLE_DEFINED) && defined(VUINT8x2_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(u, 8, 4, 2)
+# define VUINT8x4_CMPLE_DEFINED
+#endif
+
+#if !defined(VUINT8x4_CMPGE_DEFINED) && defined(VUINT8x2_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(u, 8, 4, 2)
+# define VUINT8x4_CMPGE_DEFINED
+#endif
+
+#if !defined(VUINT8x4_MIN_DEFINED) && defined(VUINT8x2_MIN_DEFINED)
+VEC_DOUBLE_MIN(u, 8, 4, 2)
+# define VUINT8x4_MIN_DEFINED
+#endif
+
+#if !defined(VUINT8x4_MAX_DEFINED) && defined(VUINT8x2_MAX_DEFINED)
+VEC_DOUBLE_MAX(u, 8, 4, 2)
+# define VUINT8x4_MAX_DEFINED
+#endif
+
+#if !defined(VUINT8x4_RSHIFT_DEFINED) && defined(VUINT8x2_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(u, 8, 4, 2)
+# define VUINT8x4_RSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT8x4_LRSHIFT_DEFINED) && defined(VUINT8x2_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(u, 8, 4, 2)
+# define VUINT8x4_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT8x4_LSHIFT_DEFINED) && defined(VUINT8x2_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(u, 8, 4, 2)
+# define VUINT8x4_LSHIFT_DEFINED
+#endif
+
+
+
+/* vuint8x8 */
+
+#if !defined(VINT8x8_SPLAT_DEFINED) && defined(VINT8x4_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(/* nothing */, 8, 8, 4)
+# define VINT8x8_SPLAT_DEFINED
+#endif
+
+#if !defined(VINT8x8_LOAD_ALIGNED_DEFINED) && defined(VINT8x4_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 8, 8, 4)
+# define VINT8x8_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT8x8_LOAD_DEFINED) && defined(VINT8x4_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(/* nothing */, 8, 8, 4)
+# define VINT8x8_LOAD_DEFINED
+#endif
+
+#if !defined(VINT8x8_STORE_ALIGNED_DEFINED) && defined(VINT8x4_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 8, 8, 4)
+# define VINT8x8_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT8x8_STORE_DEFINED) && defined(VINT8x4_STORE_DEFINED)
+VEC_DOUBLE_STORE(/* nothing */, 8, 8, 4)
+# define VINT8x8_STORE_DEFINED
+#endif
+
+#if !defined(VINT8x8_ADD_DEFINED) && defined(VINT8x4_ADD_DEFINED)
+VEC_DOUBLE_ADD(/* nothing */, 8, 8, 4)
+# define VINT8x8_ADD_DEFINED
+#endif
+
+#if !defined(VINT8x8_SUB_DEFINED) && defined(VINT8x4_SUB_DEFINED)
+VEC_DOUBLE_SUB(/* nothing */, 8, 8, 4)
+# define VINT8x8_SUB_DEFINED
+#endif
+
+#if !defined(VINT8x8_MUL_DEFINED) && defined(VINT8x4_MUL_DEFINED)
+VEC_DOUBLE_MUL(/* nothing */, 8, 8, 4)
+# define VINT8x8_MUL_DEFINED
+#endif
+
+#if !defined(VINT8x8_DIV_DEFINED) && defined(VINT8x4_DIV_DEFINED)
+VEC_DOUBLE_DIV(/* nothing */, 8, 8, 4)
+# define VINT8x8_DIV_DEFINED
+#endif
+
+#if !defined(VINT8x8_MOD_DEFINED) && defined(VINT8x4_MOD_DEFINED)
+VEC_DOUBLE_MOD(/* nothing */, 8, 8, 4)
+# define VINT8x8_MOD_DEFINED
+#endif
+
+#if !defined(VINT8x8_AVG_DEFINED) && defined(VINT8x4_AVG_DEFINED)
+VEC_DOUBLE_AVG(/* nothing */, 8, 8, 4)
+# define VINT8x8_AVG_DEFINED
+#endif
+
+#if !defined(VINT8x8_AND_DEFINED) && defined(VINT8x4_AND_DEFINED)
+VEC_DOUBLE_AND(/* nothing */, 8, 8, 4)
+# define VINT8x8_AND_DEFINED
+#endif
+
+#if !defined(VINT8x8_OR_DEFINED) && defined(VINT8x4_OR_DEFINED)
+VEC_DOUBLE_OR(/* nothing */, 8, 8, 4)
+# define VINT8x8_OR_DEFINED
+#endif
+
+#if !defined(VINT8x8_XOR_DEFINED) && defined(VINT8x4_XOR_DEFINED)
+VEC_DOUBLE_XOR(/* nothing */, 8, 8, 4)
+# define VINT8x8_XOR_DEFINED
+#endif
+
+#if !defined(VINT8x8_NOT_DEFINED) && defined(VINT8x4_NOT_DEFINED)
+VEC_DOUBLE_NOT(/* nothing */, 8, 8, 4)
+# define VINT8x8_NOT_DEFINED
+#endif
+
+#if !defined(VINT8x8_CMPLT_DEFINED) && defined(VINT8x4_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(/* nothing */, 8, 8, 4)
+# define VINT8x8_CMPLT_DEFINED
+#endif
+
+#if !defined(VINT8x8_CMPEQ_DEFINED) && defined(VINT8x4_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(/* nothing */, 8, 8, 4)
+# define VINT8x8_CMPEQ_DEFINED
+#endif
+
+#if !defined(VINT8x8_CMPGT_DEFINED) && defined(VINT8x4_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(/* nothing */, 8, 8, 4)
+# define VINT8x8_CMPGT_DEFINED
+#endif
+
+#if !defined(VINT8x8_CMPLE_DEFINED) && defined(VINT8x4_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(/* nothing */, 8, 8, 4)
+# define VINT8x8_CMPLE_DEFINED
+#endif
+
+#if !defined(VINT8x8_CMPGE_DEFINED) && defined(VINT8x4_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(/* nothing */, 8, 8, 4)
+# define VINT8x8_CMPGE_DEFINED
+#endif
+
+#if !defined(VINT8x8_MIN_DEFINED) && defined(VINT8x4_MIN_DEFINED)
+VEC_DOUBLE_MIN(/* nothing */, 8, 8, 4)
+# define VINT8x8_MIN_DEFINED
+#endif
+
+#if !defined(VINT8x8_MAX_DEFINED) && defined(VINT8x4_MAX_DEFINED)
+VEC_DOUBLE_MAX(/* nothing */, 8, 8, 4)
+# define VINT8x8_MAX_DEFINED
+#endif
+
+#if !defined(VINT8x8_RSHIFT_DEFINED) && defined(VINT8x4_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(/* nothing */, 8, 8, 4)
+# define VINT8x8_RSHIFT_DEFINED
+#endif
+
+#if !defined(VINT8x8_LRSHIFT_DEFINED) && defined(VINT8x4_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(/* nothing */, 8, 8, 4)
+# define VINT8x8_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VINT8x8_LSHIFT_DEFINED) && defined(VINT8x4_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(/* nothing */, 8, 8, 4)
+# define VINT8x8_LSHIFT_DEFINED
+#endif
+
+
+
+/* vint8x8 */
+
+#if !defined(VUINT8x8_SPLAT_DEFINED) && defined(VUINT8x4_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(u, 8, 8, 4)
+# define VUINT8x8_SPLAT_DEFINED
+#endif
+
+#if !defined(VUINT8x8_LOAD_ALIGNED_DEFINED) && defined(VUINT8x4_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(u, 8, 8, 4)
+# define VUINT8x8_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT8x8_LOAD_DEFINED) && defined(VUINT8x4_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(u, 8, 8, 4)
+# define VUINT8x8_LOAD_DEFINED
+#endif
+
+#if !defined(VUINT8x8_STORE_ALIGNED_DEFINED) && defined(VUINT8x4_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(u, 8, 8, 4)
+# define VUINT8x8_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT8x8_STORE_DEFINED) && defined(VUINT8x4_STORE_DEFINED)
+VEC_DOUBLE_STORE(u, 8, 8, 4)
+# define VUINT8x8_STORE_DEFINED
+#endif
+
+#if !defined(VUINT8x8_ADD_DEFINED) && defined(VUINT8x4_ADD_DEFINED)
+VEC_DOUBLE_ADD(u, 8, 8, 4)
+# define VUINT8x8_ADD_DEFINED
+#endif
+
+#if !defined(VUINT8x8_SUB_DEFINED) && defined(VUINT8x4_SUB_DEFINED)
+VEC_DOUBLE_SUB(u, 8, 8, 4)
+# define VUINT8x8_SUB_DEFINED
+#endif
+
+#if !defined(VUINT8x8_MUL_DEFINED) && defined(VUINT8x4_MUL_DEFINED)
+VEC_DOUBLE_MUL(u, 8, 8, 4)
+# define VUINT8x8_MUL_DEFINED
+#endif
+
+#if !defined(VUINT8x8_DIV_DEFINED) && defined(VUINT8x4_DIV_DEFINED)
+VEC_DOUBLE_DIV(u, 8, 8, 4)
+# define VUINT8x8_DIV_DEFINED
+#endif
+
+#if !defined(VUINT8x8_MOD_DEFINED) && defined(VUINT8x4_MOD_DEFINED)
+VEC_DOUBLE_MOD(u, 8, 8, 4)
+# define VUINT8x8_MOD_DEFINED
+#endif
+
+#if !defined(VUINT8x8_AVG_DEFINED) && defined(VUINT8x4_AVG_DEFINED)
+VEC_DOUBLE_AVG(u, 8, 8, 4)
+# define VUINT8x8_AVG_DEFINED
+#endif
+
+#if !defined(VUINT8x8_AND_DEFINED) && defined(VUINT8x4_AND_DEFINED)
+VEC_DOUBLE_AND(u, 8, 8, 4)
+# define VUINT8x8_AND_DEFINED
+#endif
+
+#if !defined(VUINT8x8_OR_DEFINED) && defined(VUINT8x4_OR_DEFINED)
+VEC_DOUBLE_OR(u, 8, 8, 4)
+# define VUINT8x8_OR_DEFINED
+#endif
+
+#if !defined(VUINT8x8_XOR_DEFINED) && defined(VUINT8x4_XOR_DEFINED)
+VEC_DOUBLE_XOR(u, 8, 8, 4)
+# define VUINT8x8_XOR_DEFINED
+#endif
+
+#if !defined(VUINT8x8_NOT_DEFINED) && defined(VUINT8x4_NOT_DEFINED)
+VEC_DOUBLE_NOT(u, 8, 8, 4)
+# define VUINT8x8_NOT_DEFINED
+#endif
+
+#if !defined(VUINT8x8_CMPLT_DEFINED) && defined(VUINT8x4_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(u, 8, 8, 4)
+# define VUINT8x8_CMPLT_DEFINED
+#endif
+
+#if !defined(VUINT8x8_CMPEQ_DEFINED) && defined(VUINT8x4_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(u, 8, 8, 4)
+# define VUINT8x8_CMPEQ_DEFINED
+#endif
+
+#if !defined(VUINT8x8_CMPGT_DEFINED) && defined(VUINT8x4_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(u, 8, 8, 4)
+# define VUINT8x8_CMPGT_DEFINED
+#endif
+
+#if !defined(VUINT8x8_CMPLE_DEFINED) && defined(VUINT8x4_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(u, 8, 8, 4)
+# define VUINT8x8_CMPLE_DEFINED
+#endif
+
+#if !defined(VUINT8x8_CMPGE_DEFINED) && defined(VUINT8x4_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(u, 8, 8, 4)
+# define VUINT8x8_CMPGE_DEFINED
+#endif
+
+#if !defined(VUINT8x8_MIN_DEFINED) && defined(VUINT8x4_MIN_DEFINED)
+VEC_DOUBLE_MIN(u, 8, 8, 4)
+# define VUINT8x8_MIN_DEFINED
+#endif
+
+#if !defined(VUINT8x8_MAX_DEFINED) && defined(VUINT8x4_MAX_DEFINED)
+VEC_DOUBLE_MAX(u, 8, 8, 4)
+# define VUINT8x8_MAX_DEFINED
+#endif
+
+#if !defined(VUINT8x8_RSHIFT_DEFINED) && defined(VUINT8x4_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(u, 8, 8, 4)
+# define VUINT8x8_RSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT8x8_LRSHIFT_DEFINED) && defined(VUINT8x4_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(u, 8, 8, 4)
+# define VUINT8x8_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT8x8_LSHIFT_DEFINED) && defined(VUINT8x4_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(u, 8, 8, 4)
+# define VUINT8x8_LSHIFT_DEFINED
+#endif
+
+
+
+/* vuint8x16 */
+
+#if !defined(VINT8x16_SPLAT_DEFINED) && defined(VINT8x8_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(/* nothing */, 8, 16, 8)
+# define VINT8x16_SPLAT_DEFINED
+#endif
+
+#if !defined(VINT8x16_LOAD_ALIGNED_DEFINED) && defined(VINT8x8_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 8, 16, 8)
+# define VINT8x16_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT8x16_LOAD_DEFINED) && defined(VINT8x8_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(/* nothing */, 8, 16, 8)
+# define VINT8x16_LOAD_DEFINED
+#endif
+
+#if !defined(VINT8x16_STORE_ALIGNED_DEFINED) && defined(VINT8x8_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 8, 16, 8)
+# define VINT8x16_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT8x16_STORE_DEFINED) && defined(VINT8x8_STORE_DEFINED)
+VEC_DOUBLE_STORE(/* nothing */, 8, 16, 8)
+# define VINT8x16_STORE_DEFINED
+#endif
+
+#if !defined(VINT8x16_ADD_DEFINED) && defined(VINT8x8_ADD_DEFINED)
+VEC_DOUBLE_ADD(/* nothing */, 8, 16, 8)
+# define VINT8x16_ADD_DEFINED
+#endif
+
+#if !defined(VINT8x16_SUB_DEFINED) && defined(VINT8x8_SUB_DEFINED)
+VEC_DOUBLE_SUB(/* nothing */, 8, 16, 8)
+# define VINT8x16_SUB_DEFINED
+#endif
+
+#if !defined(VINT8x16_MUL_DEFINED) && defined(VINT8x8_MUL_DEFINED)
+VEC_DOUBLE_MUL(/* nothing */, 8, 16, 8)
+# define VINT8x16_MUL_DEFINED
+#endif
+
+#if !defined(VINT8x16_DIV_DEFINED) && defined(VINT8x8_DIV_DEFINED)
+VEC_DOUBLE_DIV(/* nothing */, 8, 16, 8)
+# define VINT8x16_DIV_DEFINED
+#endif
+
+#if !defined(VINT8x16_MOD_DEFINED) && defined(VINT8x8_MOD_DEFINED)
+VEC_DOUBLE_MOD(/* nothing */, 8, 16, 8)
+# define VINT8x16_MOD_DEFINED
+#endif
+
+#if !defined(VINT8x16_AVG_DEFINED) && defined(VINT8x8_AVG_DEFINED)
+VEC_DOUBLE_AVG(/* nothing */, 8, 16, 8)
+# define VINT8x16_AVG_DEFINED
+#endif
+
+#if !defined(VINT8x16_AND_DEFINED) && defined(VINT8x8_AND_DEFINED)
+VEC_DOUBLE_AND(/* nothing */, 8, 16, 8)
+# define VINT8x16_AND_DEFINED
+#endif
+
+#if !defined(VINT8x16_OR_DEFINED) && defined(VINT8x8_OR_DEFINED)
+VEC_DOUBLE_OR(/* nothing */, 8, 16, 8)
+# define VINT8x16_OR_DEFINED
+#endif
+
+#if !defined(VINT8x16_XOR_DEFINED) && defined(VINT8x8_XOR_DEFINED)
+VEC_DOUBLE_XOR(/* nothing */, 8, 16, 8)
+# define VINT8x16_XOR_DEFINED
+#endif
+
+#if !defined(VINT8x16_NOT_DEFINED) && defined(VINT8x8_NOT_DEFINED)
+VEC_DOUBLE_NOT(/* nothing */, 8, 16, 8)
+# define VINT8x16_NOT_DEFINED
+#endif
+
+#if !defined(VINT8x16_CMPLT_DEFINED) && defined(VINT8x8_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(/* nothing */, 8, 16, 8)
+# define VINT8x16_CMPLT_DEFINED
+#endif
+
+#if !defined(VINT8x16_CMPEQ_DEFINED) && defined(VINT8x8_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(/* nothing */, 8, 16, 8)
+# define VINT8x16_CMPEQ_DEFINED
+#endif
+
+#if !defined(VINT8x16_CMPGT_DEFINED) && defined(VINT8x8_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(/* nothing */, 8, 16, 8)
+# define VINT8x16_CMPGT_DEFINED
+#endif
+
+#if !defined(VINT8x16_CMPLE_DEFINED) && defined(VINT8x8_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(/* nothing */, 8, 16, 8)
+# define VINT8x16_CMPLE_DEFINED
+#endif
+
+#if !defined(VINT8x16_CMPGE_DEFINED) && defined(VINT8x8_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(/* nothing */, 8, 16, 8)
+# define VINT8x16_CMPGE_DEFINED
+#endif
+
+#if !defined(VINT8x16_MIN_DEFINED) && defined(VINT8x8_MIN_DEFINED)
+VEC_DOUBLE_MIN(/* nothing */, 8, 16, 8)
+# define VINT8x16_MIN_DEFINED
+#endif
+
+#if !defined(VINT8x16_MAX_DEFINED) && defined(VINT8x8_MAX_DEFINED)
+VEC_DOUBLE_MAX(/* nothing */, 8, 16, 8)
+# define VINT8x16_MAX_DEFINED
+#endif
+
+#if !defined(VINT8x16_RSHIFT_DEFINED) && defined(VINT8x8_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(/* nothing */, 8, 16, 8)
+# define VINT8x16_RSHIFT_DEFINED
+#endif
+
+#if !defined(VINT8x16_LRSHIFT_DEFINED) && defined(VINT8x8_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(/* nothing */, 8, 16, 8)
+# define VINT8x16_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VINT8x16_LSHIFT_DEFINED) && defined(VINT8x8_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(/* nothing */, 8, 16, 8)
+# define VINT8x16_LSHIFT_DEFINED
+#endif
+
+
+
+/* vint8x16 */
+
+#if !defined(VUINT8x16_SPLAT_DEFINED) && defined(VUINT8x8_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(u, 8, 16, 8)
+# define VUINT8x16_SPLAT_DEFINED
+#endif
+
+#if !defined(VUINT8x16_LOAD_ALIGNED_DEFINED) && defined(VUINT8x8_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(u, 8, 16, 8)
+# define VUINT8x16_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT8x16_LOAD_DEFINED) && defined(VUINT8x8_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(u, 8, 16, 8)
+# define VUINT8x16_LOAD_DEFINED
+#endif
+
+#if !defined(VUINT8x16_STORE_ALIGNED_DEFINED) && defined(VUINT8x8_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(u, 8, 16, 8)
+# define VUINT8x16_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT8x16_STORE_DEFINED) && defined(VUINT8x8_STORE_DEFINED)
+VEC_DOUBLE_STORE(u, 8, 16, 8)
+# define VUINT8x16_STORE_DEFINED
+#endif
+
+#if !defined(VUINT8x16_ADD_DEFINED) && defined(VUINT8x8_ADD_DEFINED)
+VEC_DOUBLE_ADD(u, 8, 16, 8)
+# define VUINT8x16_ADD_DEFINED
+#endif
+
+#if !defined(VUINT8x16_SUB_DEFINED) && defined(VUINT8x8_SUB_DEFINED)
+VEC_DOUBLE_SUB(u, 8, 16, 8)
+# define VUINT8x16_SUB_DEFINED
+#endif
+
+#if !defined(VUINT8x16_MUL_DEFINED) && defined(VUINT8x8_MUL_DEFINED)
+VEC_DOUBLE_MUL(u, 8, 16, 8)
+# define VUINT8x16_MUL_DEFINED
+#endif
+
+#if !defined(VUINT8x16_DIV_DEFINED) && defined(VUINT8x8_DIV_DEFINED)
+VEC_DOUBLE_DIV(u, 8, 16, 8)
+# define VUINT8x16_DIV_DEFINED
+#endif
+
+#if !defined(VUINT8x16_MOD_DEFINED) && defined(VUINT8x8_MOD_DEFINED)
+VEC_DOUBLE_MOD(u, 8, 16, 8)
+# define VUINT8x16_MOD_DEFINED
+#endif
+
+#if !defined(VUINT8x16_AVG_DEFINED) && defined(VUINT8x8_AVG_DEFINED)
+VEC_DOUBLE_AVG(u, 8, 16, 8)
+# define VUINT8x16_AVG_DEFINED
+#endif
+
+#if !defined(VUINT8x16_AND_DEFINED) && defined(VUINT8x8_AND_DEFINED)
+VEC_DOUBLE_AND(u, 8, 16, 8)
+# define VUINT8x16_AND_DEFINED
+#endif
+
+#if !defined(VUINT8x16_OR_DEFINED) && defined(VUINT8x8_OR_DEFINED)
+VEC_DOUBLE_OR(u, 8, 16, 8)
+# define VUINT8x16_OR_DEFINED
+#endif
+
+#if !defined(VUINT8x16_XOR_DEFINED) && defined(VUINT8x8_XOR_DEFINED)
+VEC_DOUBLE_XOR(u, 8, 16, 8)
+# define VUINT8x16_XOR_DEFINED
+#endif
+
+#if !defined(VUINT8x16_NOT_DEFINED) && defined(VUINT8x8_NOT_DEFINED)
+VEC_DOUBLE_NOT(u, 8, 16, 8)
+# define VUINT8x16_NOT_DEFINED
+#endif
+
+#if !defined(VUINT8x16_CMPLT_DEFINED) && defined(VUINT8x8_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(u, 8, 16, 8)
+# define VUINT8x16_CMPLT_DEFINED
+#endif
+
+#if !defined(VUINT8x16_CMPEQ_DEFINED) && defined(VUINT8x8_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(u, 8, 16, 8)
+# define VUINT8x16_CMPEQ_DEFINED
+#endif
+
+#if !defined(VUINT8x16_CMPGT_DEFINED) && defined(VUINT8x8_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(u, 8, 16, 8)
+# define VUINT8x16_CMPGT_DEFINED
+#endif
+
+#if !defined(VUINT8x16_CMPLE_DEFINED) && defined(VUINT8x8_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(u, 8, 16, 8)
+# define VUINT8x16_CMPLE_DEFINED
+#endif
+
+#if !defined(VUINT8x16_CMPGE_DEFINED) && defined(VUINT8x8_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(u, 8, 16, 8)
+# define VUINT8x16_CMPGE_DEFINED
+#endif
+
+#if !defined(VUINT8x16_MIN_DEFINED) && defined(VUINT8x8_MIN_DEFINED)
+VEC_DOUBLE_MIN(u, 8, 16, 8)
+# define VUINT8x16_MIN_DEFINED
+#endif
+
+#if !defined(VUINT8x16_MAX_DEFINED) && defined(VUINT8x8_MAX_DEFINED)
+VEC_DOUBLE_MAX(u, 8, 16, 8)
+# define VUINT8x16_MAX_DEFINED
+#endif
+
+#if !defined(VUINT8x16_RSHIFT_DEFINED) && defined(VUINT8x8_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(u, 8, 16, 8)
+# define VUINT8x16_RSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT8x16_LRSHIFT_DEFINED) && defined(VUINT8x8_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(u, 8, 16, 8)
+# define VUINT8x16_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT8x16_LSHIFT_DEFINED) && defined(VUINT8x8_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(u, 8, 16, 8)
+# define VUINT8x16_LSHIFT_DEFINED
+#endif
+
+
+
+/* vuint8x32 */
+
+#if !defined(VINT8x32_SPLAT_DEFINED) && defined(VINT8x16_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(/* nothing */, 8, 32, 16)
+# define VINT8x32_SPLAT_DEFINED
+#endif
+
+#if !defined(VINT8x32_LOAD_ALIGNED_DEFINED) && defined(VINT8x16_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 8, 32, 16)
+# define VINT8x32_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT8x32_LOAD_DEFINED) && defined(VINT8x16_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(/* nothing */, 8, 32, 16)
+# define VINT8x32_LOAD_DEFINED
+#endif
+
+#if !defined(VINT8x32_STORE_ALIGNED_DEFINED) && defined(VINT8x16_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 8, 32, 16)
+# define VINT8x32_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT8x32_STORE_DEFINED) && defined(VINT8x16_STORE_DEFINED)
+VEC_DOUBLE_STORE(/* nothing */, 8, 32, 16)
+# define VINT8x32_STORE_DEFINED
+#endif
+
+#if !defined(VINT8x32_ADD_DEFINED) && defined(VINT8x16_ADD_DEFINED)
+VEC_DOUBLE_ADD(/* nothing */, 8, 32, 16)
+# define VINT8x32_ADD_DEFINED
+#endif
+
+#if !defined(VINT8x32_SUB_DEFINED) && defined(VINT8x16_SUB_DEFINED)
+VEC_DOUBLE_SUB(/* nothing */, 8, 32, 16)
+# define VINT8x32_SUB_DEFINED
+#endif
+
+#if !defined(VINT8x32_MUL_DEFINED) && defined(VINT8x16_MUL_DEFINED)
+VEC_DOUBLE_MUL(/* nothing */, 8, 32, 16)
+# define VINT8x32_MUL_DEFINED
+#endif
+
+#if !defined(VINT8x32_DIV_DEFINED) && defined(VINT8x16_DIV_DEFINED)
+VEC_DOUBLE_DIV(/* nothing */, 8, 32, 16)
+# define VINT8x32_DIV_DEFINED
+#endif
+
+#if !defined(VINT8x32_MOD_DEFINED) && defined(VINT8x16_MOD_DEFINED)
+VEC_DOUBLE_MOD(/* nothing */, 8, 32, 16)
+# define VINT8x32_MOD_DEFINED
+#endif
+
+#if !defined(VINT8x32_AVG_DEFINED) && defined(VINT8x16_AVG_DEFINED)
+VEC_DOUBLE_AVG(/* nothing */, 8, 32, 16)
+# define VINT8x32_AVG_DEFINED
+#endif
+
+#if !defined(VINT8x32_AND_DEFINED) && defined(VINT8x16_AND_DEFINED)
+VEC_DOUBLE_AND(/* nothing */, 8, 32, 16)
+# define VINT8x32_AND_DEFINED
+#endif
+
+#if !defined(VINT8x32_OR_DEFINED) && defined(VINT8x16_OR_DEFINED)
+VEC_DOUBLE_OR(/* nothing */, 8, 32, 16)
+# define VINT8x32_OR_DEFINED
+#endif
+
+#if !defined(VINT8x32_XOR_DEFINED) && defined(VINT8x16_XOR_DEFINED)
+VEC_DOUBLE_XOR(/* nothing */, 8, 32, 16)
+# define VINT8x32_XOR_DEFINED
+#endif
+
+#if !defined(VINT8x32_NOT_DEFINED) && defined(VINT8x16_NOT_DEFINED)
+VEC_DOUBLE_NOT(/* nothing */, 8, 32, 16)
+# define VINT8x32_NOT_DEFINED
+#endif
+
+#if !defined(VINT8x32_CMPLT_DEFINED) && defined(VINT8x16_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(/* nothing */, 8, 32, 16)
+# define VINT8x32_CMPLT_DEFINED
+#endif
+
+#if !defined(VINT8x32_CMPEQ_DEFINED) && defined(VINT8x16_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(/* nothing */, 8, 32, 16)
+# define VINT8x32_CMPEQ_DEFINED
+#endif
+
+#if !defined(VINT8x32_CMPGT_DEFINED) && defined(VINT8x16_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(/* nothing */, 8, 32, 16)
+# define VINT8x32_CMPGT_DEFINED
+#endif
+
+#if !defined(VINT8x32_CMPLE_DEFINED) && defined(VINT8x16_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(/* nothing */, 8, 32, 16)
+# define VINT8x32_CMPLE_DEFINED
+#endif
+
+#if !defined(VINT8x32_CMPGE_DEFINED) && defined(VINT8x16_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(/* nothing */, 8, 32, 16)
+# define VINT8x32_CMPGE_DEFINED
+#endif
+
+#if !defined(VINT8x32_MIN_DEFINED) && defined(VINT8x16_MIN_DEFINED)
+VEC_DOUBLE_MIN(/* nothing */, 8, 32, 16)
+# define VINT8x32_MIN_DEFINED
+#endif
+
+#if !defined(VINT8x32_MAX_DEFINED) && defined(VINT8x16_MAX_DEFINED)
+VEC_DOUBLE_MAX(/* nothing */, 8, 32, 16)
+# define VINT8x32_MAX_DEFINED
+#endif
+
+#if !defined(VINT8x32_RSHIFT_DEFINED) && defined(VINT8x16_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(/* nothing */, 8, 32, 16)
+# define VINT8x32_RSHIFT_DEFINED
+#endif
+
+#if !defined(VINT8x32_LRSHIFT_DEFINED) && defined(VINT8x16_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(/* nothing */, 8, 32, 16)
+# define VINT8x32_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VINT8x32_LSHIFT_DEFINED) && defined(VINT8x16_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(/* nothing */, 8, 32, 16)
+# define VINT8x32_LSHIFT_DEFINED
+#endif
+
+
+
+/* vint8x32 */
+
+#if !defined(VUINT8x32_SPLAT_DEFINED) && defined(VUINT8x16_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(u, 8, 32, 16)
+# define VUINT8x32_SPLAT_DEFINED
+#endif
+
+#if !defined(VUINT8x32_LOAD_ALIGNED_DEFINED) && defined(VUINT8x16_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(u, 8, 32, 16)
+# define VUINT8x32_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT8x32_LOAD_DEFINED) && defined(VUINT8x16_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(u, 8, 32, 16)
+# define VUINT8x32_LOAD_DEFINED
+#endif
+
+#if !defined(VUINT8x32_STORE_ALIGNED_DEFINED) && defined(VUINT8x16_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(u, 8, 32, 16)
+# define VUINT8x32_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT8x32_STORE_DEFINED) && defined(VUINT8x16_STORE_DEFINED)
+VEC_DOUBLE_STORE(u, 8, 32, 16)
+# define VUINT8x32_STORE_DEFINED
+#endif
+
+#if !defined(VUINT8x32_ADD_DEFINED) && defined(VUINT8x16_ADD_DEFINED)
+VEC_DOUBLE_ADD(u, 8, 32, 16)
+# define VUINT8x32_ADD_DEFINED
+#endif
+
+#if !defined(VUINT8x32_SUB_DEFINED) && defined(VUINT8x16_SUB_DEFINED)
+VEC_DOUBLE_SUB(u, 8, 32, 16)
+# define VUINT8x32_SUB_DEFINED
+#endif
+
+#if !defined(VUINT8x32_MUL_DEFINED) && defined(VUINT8x16_MUL_DEFINED)
+VEC_DOUBLE_MUL(u, 8, 32, 16)
+# define VUINT8x32_MUL_DEFINED
+#endif
+
+#if !defined(VUINT8x32_DIV_DEFINED) && defined(VUINT8x16_DIV_DEFINED)
+VEC_DOUBLE_DIV(u, 8, 32, 16)
+# define VUINT8x32_DIV_DEFINED
+#endif
+
+#if !defined(VUINT8x32_MOD_DEFINED) && defined(VUINT8x16_MOD_DEFINED)
+VEC_DOUBLE_MOD(u, 8, 32, 16)
+# define VUINT8x32_MOD_DEFINED
+#endif
+
+#if !defined(VUINT8x32_AVG_DEFINED) && defined(VUINT8x16_AVG_DEFINED)
+VEC_DOUBLE_AVG(u, 8, 32, 16)
+# define VUINT8x32_AVG_DEFINED
+#endif
+
+#if !defined(VUINT8x32_AND_DEFINED) && defined(VUINT8x16_AND_DEFINED)
+VEC_DOUBLE_AND(u, 8, 32, 16)
+# define VUINT8x32_AND_DEFINED
+#endif
+
+#if !defined(VUINT8x32_OR_DEFINED) && defined(VUINT8x16_OR_DEFINED)
+VEC_DOUBLE_OR(u, 8, 32, 16)
+# define VUINT8x32_OR_DEFINED
+#endif
+
+#if !defined(VUINT8x32_XOR_DEFINED) && defined(VUINT8x16_XOR_DEFINED)
+VEC_DOUBLE_XOR(u, 8, 32, 16)
+# define VUINT8x32_XOR_DEFINED
+#endif
+
+#if !defined(VUINT8x32_NOT_DEFINED) && defined(VUINT8x16_NOT_DEFINED)
+VEC_DOUBLE_NOT(u, 8, 32, 16)
+# define VUINT8x32_NOT_DEFINED
+#endif
+
+#if !defined(VUINT8x32_CMPLT_DEFINED) && defined(VUINT8x16_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(u, 8, 32, 16)
+# define VUINT8x32_CMPLT_DEFINED
+#endif
+
+#if !defined(VUINT8x32_CMPEQ_DEFINED) && defined(VUINT8x16_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(u, 8, 32, 16)
+# define VUINT8x32_CMPEQ_DEFINED
+#endif
+
+#if !defined(VUINT8x32_CMPGT_DEFINED) && defined(VUINT8x16_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(u, 8, 32, 16)
+# define VUINT8x32_CMPGT_DEFINED
+#endif
+
+#if !defined(VUINT8x32_CMPLE_DEFINED) && defined(VUINT8x16_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(u, 8, 32, 16)
+# define VUINT8x32_CMPLE_DEFINED
+#endif
+
+#if !defined(VUINT8x32_CMPGE_DEFINED) && defined(VUINT8x16_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(u, 8, 32, 16)
+# define VUINT8x32_CMPGE_DEFINED
+#endif
+
+#if !defined(VUINT8x32_MIN_DEFINED) && defined(VUINT8x16_MIN_DEFINED)
+VEC_DOUBLE_MIN(u, 8, 32, 16)
+# define VUINT8x32_MIN_DEFINED
+#endif
+
+#if !defined(VUINT8x32_MAX_DEFINED) && defined(VUINT8x16_MAX_DEFINED)
+VEC_DOUBLE_MAX(u, 8, 32, 16)
+# define VUINT8x32_MAX_DEFINED
+#endif
+
+#if !defined(VUINT8x32_RSHIFT_DEFINED) && defined(VUINT8x16_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(u, 8, 32, 16)
+# define VUINT8x32_RSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT8x32_LRSHIFT_DEFINED) && defined(VUINT8x16_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(u, 8, 32, 16)
+# define VUINT8x32_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT8x32_LSHIFT_DEFINED) && defined(VUINT8x16_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(u, 8, 32, 16)
+# define VUINT8x32_LSHIFT_DEFINED
+#endif
+
+
+
+/* vuint8x64 */
+
+#if !defined(VINT8x64_SPLAT_DEFINED) && defined(VINT8x32_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(/* nothing */, 8, 64, 32)
+# define VINT8x64_SPLAT_DEFINED
+#endif
+
+#if !defined(VINT8x64_LOAD_ALIGNED_DEFINED) && defined(VINT8x32_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 8, 64, 32)
+# define VINT8x64_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT8x64_LOAD_DEFINED) && defined(VINT8x32_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(/* nothing */, 8, 64, 32)
+# define VINT8x64_LOAD_DEFINED
+#endif
+
+#if !defined(VINT8x64_STORE_ALIGNED_DEFINED) && defined(VINT8x32_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 8, 64, 32)
+# define VINT8x64_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT8x64_STORE_DEFINED) && defined(VINT8x32_STORE_DEFINED)
+VEC_DOUBLE_STORE(/* nothing */, 8, 64, 32)
+# define VINT8x64_STORE_DEFINED
+#endif
+
+#if !defined(VINT8x64_ADD_DEFINED) && defined(VINT8x32_ADD_DEFINED)
+VEC_DOUBLE_ADD(/* nothing */, 8, 64, 32)
+# define VINT8x64_ADD_DEFINED
+#endif
+
+#if !defined(VINT8x64_SUB_DEFINED) && defined(VINT8x32_SUB_DEFINED)
+VEC_DOUBLE_SUB(/* nothing */, 8, 64, 32)
+# define VINT8x64_SUB_DEFINED
+#endif
+
+#if !defined(VINT8x64_MUL_DEFINED) && defined(VINT8x32_MUL_DEFINED)
+VEC_DOUBLE_MUL(/* nothing */, 8, 64, 32)
+# define VINT8x64_MUL_DEFINED
+#endif
+
+#if !defined(VINT8x64_DIV_DEFINED) && defined(VINT8x32_DIV_DEFINED)
+VEC_DOUBLE_DIV(/* nothing */, 8, 64, 32)
+# define VINT8x64_DIV_DEFINED
+#endif
+
+#if !defined(VINT8x64_MOD_DEFINED) && defined(VINT8x32_MOD_DEFINED)
+VEC_DOUBLE_MOD(/* nothing */, 8, 64, 32)
+# define VINT8x64_MOD_DEFINED
+#endif
+
+#if !defined(VINT8x64_AVG_DEFINED) && defined(VINT8x32_AVG_DEFINED)
+VEC_DOUBLE_AVG(/* nothing */, 8, 64, 32)
+# define VINT8x64_AVG_DEFINED
+#endif
+
+#if !defined(VINT8x64_AND_DEFINED) && defined(VINT8x32_AND_DEFINED)
+VEC_DOUBLE_AND(/* nothing */, 8, 64, 32)
+# define VINT8x64_AND_DEFINED
+#endif
+
+#if !defined(VINT8x64_OR_DEFINED) && defined(VINT8x32_OR_DEFINED)
+VEC_DOUBLE_OR(/* nothing */, 8, 64, 32)
+# define VINT8x64_OR_DEFINED
+#endif
+
+#if !defined(VINT8x64_XOR_DEFINED) && defined(VINT8x32_XOR_DEFINED)
+VEC_DOUBLE_XOR(/* nothing */, 8, 64, 32)
+# define VINT8x64_XOR_DEFINED
+#endif
+
+#if !defined(VINT8x64_NOT_DEFINED) && defined(VINT8x32_NOT_DEFINED)
+VEC_DOUBLE_NOT(/* nothing */, 8, 64, 32)
+# define VINT8x64_NOT_DEFINED
+#endif
+
+#if !defined(VINT8x64_CMPLT_DEFINED) && defined(VINT8x32_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(/* nothing */, 8, 64, 32)
+# define VINT8x64_CMPLT_DEFINED
+#endif
+
+#if !defined(VINT8x64_CMPEQ_DEFINED) && defined(VINT8x32_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(/* nothing */, 8, 64, 32)
+# define VINT8x64_CMPEQ_DEFINED
+#endif
+
+#if !defined(VINT8x64_CMPGT_DEFINED) && defined(VINT8x32_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(/* nothing */, 8, 64, 32)
+# define VINT8x64_CMPGT_DEFINED
+#endif
+
+#if !defined(VINT8x64_CMPLE_DEFINED) && defined(VINT8x32_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(/* nothing */, 8, 64, 32)
+# define VINT8x64_CMPLE_DEFINED
+#endif
+
+#if !defined(VINT8x64_CMPGE_DEFINED) && defined(VINT8x32_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(/* nothing */, 8, 64, 32)
+# define VINT8x64_CMPGE_DEFINED
+#endif
+
+#if !defined(VINT8x64_MIN_DEFINED) && defined(VINT8x32_MIN_DEFINED)
+VEC_DOUBLE_MIN(/* nothing */, 8, 64, 32)
+# define VINT8x64_MIN_DEFINED
+#endif
+
+#if !defined(VINT8x64_MAX_DEFINED) && defined(VINT8x32_MAX_DEFINED)
+VEC_DOUBLE_MAX(/* nothing */, 8, 64, 32)
+# define VINT8x64_MAX_DEFINED
+#endif
+
+#if !defined(VINT8x64_RSHIFT_DEFINED) && defined(VINT8x32_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(/* nothing */, 8, 64, 32)
+# define VINT8x64_RSHIFT_DEFINED
+#endif
+
+#if !defined(VINT8x64_LRSHIFT_DEFINED) && defined(VINT8x32_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(/* nothing */, 8, 64, 32)
+# define VINT8x64_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VINT8x64_LSHIFT_DEFINED) && defined(VINT8x32_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(/* nothing */, 8, 64, 32)
+# define VINT8x64_LSHIFT_DEFINED
+#endif
+
+
+
+/* vint8x64 */
+
+#if !defined(VUINT8x64_SPLAT_DEFINED) && defined(VUINT8x32_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(u, 8, 64, 32)
+# define VUINT8x64_SPLAT_DEFINED
+#endif
+
+#if !defined(VUINT8x64_LOAD_ALIGNED_DEFINED) && defined(VUINT8x32_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(u, 8, 64, 32)
+# define VUINT8x64_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT8x64_LOAD_DEFINED) && defined(VUINT8x32_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(u, 8, 64, 32)
+# define VUINT8x64_LOAD_DEFINED
+#endif
+
+#if !defined(VUINT8x64_STORE_ALIGNED_DEFINED) && defined(VUINT8x32_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(u, 8, 64, 32)
+# define VUINT8x64_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT8x64_STORE_DEFINED) && defined(VUINT8x32_STORE_DEFINED)
+VEC_DOUBLE_STORE(u, 8, 64, 32)
+# define VUINT8x64_STORE_DEFINED
+#endif
+
+#if !defined(VUINT8x64_ADD_DEFINED) && defined(VUINT8x32_ADD_DEFINED)
+VEC_DOUBLE_ADD(u, 8, 64, 32)
+# define VUINT8x64_ADD_DEFINED
+#endif
+
+#if !defined(VUINT8x64_SUB_DEFINED) && defined(VUINT8x32_SUB_DEFINED)
+VEC_DOUBLE_SUB(u, 8, 64, 32)
+# define VUINT8x64_SUB_DEFINED
+#endif
+
+#if !defined(VUINT8x64_MUL_DEFINED) && defined(VUINT8x32_MUL_DEFINED)
+VEC_DOUBLE_MUL(u, 8, 64, 32)
+# define VUINT8x64_MUL_DEFINED
+#endif
+
+#if !defined(VUINT8x64_DIV_DEFINED) && defined(VUINT8x32_DIV_DEFINED)
+VEC_DOUBLE_DIV(u, 8, 64, 32)
+# define VUINT8x64_DIV_DEFINED
+#endif
+
+#if !defined(VUINT8x64_MOD_DEFINED) && defined(VUINT8x32_MOD_DEFINED)
+VEC_DOUBLE_MOD(u, 8, 64, 32)
+# define VUINT8x64_MOD_DEFINED
+#endif
+
+#if !defined(VUINT8x64_AVG_DEFINED) && defined(VUINT8x32_AVG_DEFINED)
+VEC_DOUBLE_AVG(u, 8, 64, 32)
+# define VUINT8x64_AVG_DEFINED
+#endif
+
+#if !defined(VUINT8x64_AND_DEFINED) && defined(VUINT8x32_AND_DEFINED)
+VEC_DOUBLE_AND(u, 8, 64, 32)
+# define VUINT8x64_AND_DEFINED
+#endif
+
+#if !defined(VUINT8x64_OR_DEFINED) && defined(VUINT8x32_OR_DEFINED)
+VEC_DOUBLE_OR(u, 8, 64, 32)
+# define VUINT8x64_OR_DEFINED
+#endif
+
+#if !defined(VUINT8x64_XOR_DEFINED) && defined(VUINT8x32_XOR_DEFINED)
+VEC_DOUBLE_XOR(u, 8, 64, 32)
+# define VUINT8x64_XOR_DEFINED
+#endif
+
+#if !defined(VUINT8x64_NOT_DEFINED) && defined(VUINT8x32_NOT_DEFINED)
+VEC_DOUBLE_NOT(u, 8, 64, 32)
+# define VUINT8x64_NOT_DEFINED
+#endif
+
+#if !defined(VUINT8x64_CMPLT_DEFINED) && defined(VUINT8x32_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(u, 8, 64, 32)
+# define VUINT8x64_CMPLT_DEFINED
+#endif
+
+#if !defined(VUINT8x64_CMPEQ_DEFINED) && defined(VUINT8x32_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(u, 8, 64, 32)
+# define VUINT8x64_CMPEQ_DEFINED
+#endif
+
+#if !defined(VUINT8x64_CMPGT_DEFINED) && defined(VUINT8x32_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(u, 8, 64, 32)
+# define VUINT8x64_CMPGT_DEFINED
+#endif
+
+#if !defined(VUINT8x64_CMPLE_DEFINED) && defined(VUINT8x32_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(u, 8, 64, 32)
+# define VUINT8x64_CMPLE_DEFINED
+#endif
+
+#if !defined(VUINT8x64_CMPGE_DEFINED) && defined(VUINT8x32_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(u, 8, 64, 32)
+# define VUINT8x64_CMPGE_DEFINED
+#endif
+
+#if !defined(VUINT8x64_MIN_DEFINED) && defined(VUINT8x32_MIN_DEFINED)
+VEC_DOUBLE_MIN(u, 8, 64, 32)
+# define VUINT8x64_MIN_DEFINED
+#endif
+
+#if !defined(VUINT8x64_MAX_DEFINED) && defined(VUINT8x32_MAX_DEFINED)
+VEC_DOUBLE_MAX(u, 8, 64, 32)
+# define VUINT8x64_MAX_DEFINED
+#endif
+
+#if !defined(VUINT8x64_RSHIFT_DEFINED) && defined(VUINT8x32_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(u, 8, 64, 32)
+# define VUINT8x64_RSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT8x64_LRSHIFT_DEFINED) && defined(VUINT8x32_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(u, 8, 64, 32)
+# define VUINT8x64_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT8x64_LSHIFT_DEFINED) && defined(VUINT8x32_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(u, 8, 64, 32)
+# define VUINT8x64_LSHIFT_DEFINED
+#endif
+
+
+
+/* vuint16x4 */
+
+#if !defined(VINT16x4_SPLAT_DEFINED) && defined(VINT16x2_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(/* nothing */, 16, 4, 2)
+# define VINT16x4_SPLAT_DEFINED
+#endif
+
+#if !defined(VINT16x4_LOAD_ALIGNED_DEFINED) && defined(VINT16x2_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 16, 4, 2)
+# define VINT16x4_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT16x4_LOAD_DEFINED) && defined(VINT16x2_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(/* nothing */, 16, 4, 2)
+# define VINT16x4_LOAD_DEFINED
+#endif
+
+#if !defined(VINT16x4_STORE_ALIGNED_DEFINED) && defined(VINT16x2_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 16, 4, 2)
+# define VINT16x4_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT16x4_STORE_DEFINED) && defined(VINT16x2_STORE_DEFINED)
+VEC_DOUBLE_STORE(/* nothing */, 16, 4, 2)
+# define VINT16x4_STORE_DEFINED
+#endif
+
+#if !defined(VINT16x4_ADD_DEFINED) && defined(VINT16x2_ADD_DEFINED)
+VEC_DOUBLE_ADD(/* nothing */, 16, 4, 2)
+# define VINT16x4_ADD_DEFINED
+#endif
+
+#if !defined(VINT16x4_SUB_DEFINED) && defined(VINT16x2_SUB_DEFINED)
+VEC_DOUBLE_SUB(/* nothing */, 16, 4, 2)
+# define VINT16x4_SUB_DEFINED
+#endif
+
+#if !defined(VINT16x4_MUL_DEFINED) && defined(VINT16x2_MUL_DEFINED)
+VEC_DOUBLE_MUL(/* nothing */, 16, 4, 2)
+# define VINT16x4_MUL_DEFINED
+#endif
+
+#if !defined(VINT16x4_DIV_DEFINED) && defined(VINT16x2_DIV_DEFINED)
+VEC_DOUBLE_DIV(/* nothing */, 16, 4, 2)
+# define VINT16x4_DIV_DEFINED
+#endif
+
+#if !defined(VINT16x4_MOD_DEFINED) && defined(VINT16x2_MOD_DEFINED)
+VEC_DOUBLE_MOD(/* nothing */, 16, 4, 2)
+# define VINT16x4_MOD_DEFINED
+#endif
+
+#if !defined(VINT16x4_AVG_DEFINED) && defined(VINT16x2_AVG_DEFINED)
+VEC_DOUBLE_AVG(/* nothing */, 16, 4, 2)
+# define VINT16x4_AVG_DEFINED
+#endif
+
+#if !defined(VINT16x4_AND_DEFINED) && defined(VINT16x2_AND_DEFINED)
+VEC_DOUBLE_AND(/* nothing */, 16, 4, 2)
+# define VINT16x4_AND_DEFINED
+#endif
+
+#if !defined(VINT16x4_OR_DEFINED) && defined(VINT16x2_OR_DEFINED)
+VEC_DOUBLE_OR(/* nothing */, 16, 4, 2)
+# define VINT16x4_OR_DEFINED
+#endif
+
+#if !defined(VINT16x4_XOR_DEFINED) && defined(VINT16x2_XOR_DEFINED)
+VEC_DOUBLE_XOR(/* nothing */, 16, 4, 2)
+# define VINT16x4_XOR_DEFINED
+#endif
+
+#if !defined(VINT16x4_NOT_DEFINED) && defined(VINT16x2_NOT_DEFINED)
+VEC_DOUBLE_NOT(/* nothing */, 16, 4, 2)
+# define VINT16x4_NOT_DEFINED
+#endif
+
+#if !defined(VINT16x4_CMPLT_DEFINED) && defined(VINT16x2_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(/* nothing */, 16, 4, 2)
+# define VINT16x4_CMPLT_DEFINED
+#endif
+
+#if !defined(VINT16x4_CMPEQ_DEFINED) && defined(VINT16x2_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(/* nothing */, 16, 4, 2)
+# define VINT16x4_CMPEQ_DEFINED
+#endif
+
+#if !defined(VINT16x4_CMPGT_DEFINED) && defined(VINT16x2_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(/* nothing */, 16, 4, 2)
+# define VINT16x4_CMPGT_DEFINED
+#endif
+
+#if !defined(VINT16x4_CMPLE_DEFINED) && defined(VINT16x2_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(/* nothing */, 16, 4, 2)
+# define VINT16x4_CMPLE_DEFINED
+#endif
+
+#if !defined(VINT16x4_CMPGE_DEFINED) && defined(VINT16x2_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(/* nothing */, 16, 4, 2)
+# define VINT16x4_CMPGE_DEFINED
+#endif
+
+#if !defined(VINT16x4_MIN_DEFINED) && defined(VINT16x2_MIN_DEFINED)
+VEC_DOUBLE_MIN(/* nothing */, 16, 4, 2)
+# define VINT16x4_MIN_DEFINED
+#endif
+
+#if !defined(VINT16x4_MAX_DEFINED) && defined(VINT16x2_MAX_DEFINED)
+VEC_DOUBLE_MAX(/* nothing */, 16, 4, 2)
+# define VINT16x4_MAX_DEFINED
+#endif
+
+#if !defined(VINT16x4_RSHIFT_DEFINED) && defined(VINT16x2_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(/* nothing */, 16, 4, 2)
+# define VINT16x4_RSHIFT_DEFINED
+#endif
+
+#if !defined(VINT16x4_LRSHIFT_DEFINED) && defined(VINT16x2_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(/* nothing */, 16, 4, 2)
+# define VINT16x4_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VINT16x4_LSHIFT_DEFINED) && defined(VINT16x2_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(/* nothing */, 16, 4, 2)
+# define VINT16x4_LSHIFT_DEFINED
+#endif
+
+
+
+/* vint16x4 */
+
+#if !defined(VUINT16x4_SPLAT_DEFINED) && defined(VUINT16x2_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(u, 16, 4, 2)
+# define VUINT16x4_SPLAT_DEFINED
+#endif
+
+#if !defined(VUINT16x4_LOAD_ALIGNED_DEFINED) && defined(VUINT16x2_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(u, 16, 4, 2)
+# define VUINT16x4_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT16x4_LOAD_DEFINED) && defined(VUINT16x2_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(u, 16, 4, 2)
+# define VUINT16x4_LOAD_DEFINED
+#endif
+
+#if !defined(VUINT16x4_STORE_ALIGNED_DEFINED) && defined(VUINT16x2_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(u, 16, 4, 2)
+# define VUINT16x4_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT16x4_STORE_DEFINED) && defined(VUINT16x2_STORE_DEFINED)
+VEC_DOUBLE_STORE(u, 16, 4, 2)
+# define VUINT16x4_STORE_DEFINED
+#endif
+
+#if !defined(VUINT16x4_ADD_DEFINED) && defined(VUINT16x2_ADD_DEFINED)
+VEC_DOUBLE_ADD(u, 16, 4, 2)
+# define VUINT16x4_ADD_DEFINED
+#endif
+
+#if !defined(VUINT16x4_SUB_DEFINED) && defined(VUINT16x2_SUB_DEFINED)
+VEC_DOUBLE_SUB(u, 16, 4, 2)
+# define VUINT16x4_SUB_DEFINED
+#endif
+
+#if !defined(VUINT16x4_MUL_DEFINED) && defined(VUINT16x2_MUL_DEFINED)
+VEC_DOUBLE_MUL(u, 16, 4, 2)
+# define VUINT16x4_MUL_DEFINED
+#endif
+
+#if !defined(VUINT16x4_DIV_DEFINED) && defined(VUINT16x2_DIV_DEFINED)
+VEC_DOUBLE_DIV(u, 16, 4, 2)
+# define VUINT16x4_DIV_DEFINED
+#endif
+
+#if !defined(VUINT16x4_MOD_DEFINED) && defined(VUINT16x2_MOD_DEFINED)
+VEC_DOUBLE_MOD(u, 16, 4, 2)
+# define VUINT16x4_MOD_DEFINED
+#endif
+
+#if !defined(VUINT16x4_AVG_DEFINED) && defined(VUINT16x2_AVG_DEFINED)
+VEC_DOUBLE_AVG(u, 16, 4, 2)
+# define VUINT16x4_AVG_DEFINED
+#endif
+
+#if !defined(VUINT16x4_AND_DEFINED) && defined(VUINT16x2_AND_DEFINED)
+VEC_DOUBLE_AND(u, 16, 4, 2)
+# define VUINT16x4_AND_DEFINED
+#endif
+
+#if !defined(VUINT16x4_OR_DEFINED) && defined(VUINT16x2_OR_DEFINED)
+VEC_DOUBLE_OR(u, 16, 4, 2)
+# define VUINT16x4_OR_DEFINED
+#endif
+
+#if !defined(VUINT16x4_XOR_DEFINED) && defined(VUINT16x2_XOR_DEFINED)
+VEC_DOUBLE_XOR(u, 16, 4, 2)
+# define VUINT16x4_XOR_DEFINED
+#endif
+
+#if !defined(VUINT16x4_NOT_DEFINED) && defined(VUINT16x2_NOT_DEFINED)
+VEC_DOUBLE_NOT(u, 16, 4, 2)
+# define VUINT16x4_NOT_DEFINED
+#endif
+
+#if !defined(VUINT16x4_CMPLT_DEFINED) && defined(VUINT16x2_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(u, 16, 4, 2)
+# define VUINT16x4_CMPLT_DEFINED
+#endif
+
+#if !defined(VUINT16x4_CMPEQ_DEFINED) && defined(VUINT16x2_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(u, 16, 4, 2)
+# define VUINT16x4_CMPEQ_DEFINED
+#endif
+
+#if !defined(VUINT16x4_CMPGT_DEFINED) && defined(VUINT16x2_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(u, 16, 4, 2)
+# define VUINT16x4_CMPGT_DEFINED
+#endif
+
+#if !defined(VUINT16x4_CMPLE_DEFINED) && defined(VUINT16x2_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(u, 16, 4, 2)
+# define VUINT16x4_CMPLE_DEFINED
+#endif
+
+#if !defined(VUINT16x4_CMPGE_DEFINED) && defined(VUINT16x2_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(u, 16, 4, 2)
+# define VUINT16x4_CMPGE_DEFINED
+#endif
+
+#if !defined(VUINT16x4_MIN_DEFINED) && defined(VUINT16x2_MIN_DEFINED)
+VEC_DOUBLE_MIN(u, 16, 4, 2)
+# define VUINT16x4_MIN_DEFINED
+#endif
+
+#if !defined(VUINT16x4_MAX_DEFINED) && defined(VUINT16x2_MAX_DEFINED)
+VEC_DOUBLE_MAX(u, 16, 4, 2)
+# define VUINT16x4_MAX_DEFINED
+#endif
+
+#if !defined(VUINT16x4_RSHIFT_DEFINED) && defined(VUINT16x2_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(u, 16, 4, 2)
+# define VUINT16x4_RSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT16x4_LRSHIFT_DEFINED) && defined(VUINT16x2_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(u, 16, 4, 2)
+# define VUINT16x4_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT16x4_LSHIFT_DEFINED) && defined(VUINT16x2_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(u, 16, 4, 2)
+# define VUINT16x4_LSHIFT_DEFINED
+#endif
+
+
+
+/* vuint16x8 */
+
+#if !defined(VINT16x8_SPLAT_DEFINED) && defined(VINT16x4_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(/* nothing */, 16, 8, 4)
+# define VINT16x8_SPLAT_DEFINED
+#endif
+
+#if !defined(VINT16x8_LOAD_ALIGNED_DEFINED) && defined(VINT16x4_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 16, 8, 4)
+# define VINT16x8_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT16x8_LOAD_DEFINED) && defined(VINT16x4_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(/* nothing */, 16, 8, 4)
+# define VINT16x8_LOAD_DEFINED
+#endif
+
+#if !defined(VINT16x8_STORE_ALIGNED_DEFINED) && defined(VINT16x4_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 16, 8, 4)
+# define VINT16x8_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT16x8_STORE_DEFINED) && defined(VINT16x4_STORE_DEFINED)
+VEC_DOUBLE_STORE(/* nothing */, 16, 8, 4)
+# define VINT16x8_STORE_DEFINED
+#endif
+
+#if !defined(VINT16x8_ADD_DEFINED) && defined(VINT16x4_ADD_DEFINED)
+VEC_DOUBLE_ADD(/* nothing */, 16, 8, 4)
+# define VINT16x8_ADD_DEFINED
+#endif
+
+#if !defined(VINT16x8_SUB_DEFINED) && defined(VINT16x4_SUB_DEFINED)
+VEC_DOUBLE_SUB(/* nothing */, 16, 8, 4)
+# define VINT16x8_SUB_DEFINED
+#endif
+
+#if !defined(VINT16x8_MUL_DEFINED) && defined(VINT16x4_MUL_DEFINED)
+VEC_DOUBLE_MUL(/* nothing */, 16, 8, 4)
+# define VINT16x8_MUL_DEFINED
+#endif
+
+#if !defined(VINT16x8_DIV_DEFINED) && defined(VINT16x4_DIV_DEFINED)
+VEC_DOUBLE_DIV(/* nothing */, 16, 8, 4)
+# define VINT16x8_DIV_DEFINED
+#endif
+
+#if !defined(VINT16x8_MOD_DEFINED) && defined(VINT16x4_MOD_DEFINED)
+VEC_DOUBLE_MOD(/* nothing */, 16, 8, 4)
+# define VINT16x8_MOD_DEFINED
+#endif
+
+#if !defined(VINT16x8_AVG_DEFINED) && defined(VINT16x4_AVG_DEFINED)
+VEC_DOUBLE_AVG(/* nothing */, 16, 8, 4)
+# define VINT16x8_AVG_DEFINED
+#endif
+
+#if !defined(VINT16x8_AND_DEFINED) && defined(VINT16x4_AND_DEFINED)
+VEC_DOUBLE_AND(/* nothing */, 16, 8, 4)
+# define VINT16x8_AND_DEFINED
+#endif
+
+#if !defined(VINT16x8_OR_DEFINED) && defined(VINT16x4_OR_DEFINED)
+VEC_DOUBLE_OR(/* nothing */, 16, 8, 4)
+# define VINT16x8_OR_DEFINED
+#endif
+
+#if !defined(VINT16x8_XOR_DEFINED) && defined(VINT16x4_XOR_DEFINED)
+VEC_DOUBLE_XOR(/* nothing */, 16, 8, 4)
+# define VINT16x8_XOR_DEFINED
+#endif
+
+#if !defined(VINT16x8_NOT_DEFINED) && defined(VINT16x4_NOT_DEFINED)
+VEC_DOUBLE_NOT(/* nothing */, 16, 8, 4)
+# define VINT16x8_NOT_DEFINED
+#endif
+
+#if !defined(VINT16x8_CMPLT_DEFINED) && defined(VINT16x4_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(/* nothing */, 16, 8, 4)
+# define VINT16x8_CMPLT_DEFINED
+#endif
+
+#if !defined(VINT16x8_CMPEQ_DEFINED) && defined(VINT16x4_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(/* nothing */, 16, 8, 4)
+# define VINT16x8_CMPEQ_DEFINED
+#endif
+
+#if !defined(VINT16x8_CMPGT_DEFINED) && defined(VINT16x4_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(/* nothing */, 16, 8, 4)
+# define VINT16x8_CMPGT_DEFINED
+#endif
+
+#if !defined(VINT16x8_CMPLE_DEFINED) && defined(VINT16x4_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(/* nothing */, 16, 8, 4)
+# define VINT16x8_CMPLE_DEFINED
+#endif
+
+#if !defined(VINT16x8_CMPGE_DEFINED) && defined(VINT16x4_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(/* nothing */, 16, 8, 4)
+# define VINT16x8_CMPGE_DEFINED
+#endif
+
+#if !defined(VINT16x8_MIN_DEFINED) && defined(VINT16x4_MIN_DEFINED)
+VEC_DOUBLE_MIN(/* nothing */, 16, 8, 4)
+# define VINT16x8_MIN_DEFINED
+#endif
+
+#if !defined(VINT16x8_MAX_DEFINED) && defined(VINT16x4_MAX_DEFINED)
+VEC_DOUBLE_MAX(/* nothing */, 16, 8, 4)
+# define VINT16x8_MAX_DEFINED
+#endif
+
+#if !defined(VINT16x8_RSHIFT_DEFINED) && defined(VINT16x4_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(/* nothing */, 16, 8, 4)
+# define VINT16x8_RSHIFT_DEFINED
+#endif
+
+#if !defined(VINT16x8_LRSHIFT_DEFINED) && defined(VINT16x4_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(/* nothing */, 16, 8, 4)
+# define VINT16x8_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VINT16x8_LSHIFT_DEFINED) && defined(VINT16x4_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(/* nothing */, 16, 8, 4)
+# define VINT16x8_LSHIFT_DEFINED
+#endif
+
+
+
+/* vint16x8 */
+
+#if !defined(VUINT16x8_SPLAT_DEFINED) && defined(VUINT16x4_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(u, 16, 8, 4)
+# define VUINT16x8_SPLAT_DEFINED
+#endif
+
+#if !defined(VUINT16x8_LOAD_ALIGNED_DEFINED) && defined(VUINT16x4_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(u, 16, 8, 4)
+# define VUINT16x8_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT16x8_LOAD_DEFINED) && defined(VUINT16x4_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(u, 16, 8, 4)
+# define VUINT16x8_LOAD_DEFINED
+#endif
+
+#if !defined(VUINT16x8_STORE_ALIGNED_DEFINED) && defined(VUINT16x4_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(u, 16, 8, 4)
+# define VUINT16x8_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT16x8_STORE_DEFINED) && defined(VUINT16x4_STORE_DEFINED)
+VEC_DOUBLE_STORE(u, 16, 8, 4)
+# define VUINT16x8_STORE_DEFINED
+#endif
+
+#if !defined(VUINT16x8_ADD_DEFINED) && defined(VUINT16x4_ADD_DEFINED)
+VEC_DOUBLE_ADD(u, 16, 8, 4)
+# define VUINT16x8_ADD_DEFINED
+#endif
+
+#if !defined(VUINT16x8_SUB_DEFINED) && defined(VUINT16x4_SUB_DEFINED)
+VEC_DOUBLE_SUB(u, 16, 8, 4)
+# define VUINT16x8_SUB_DEFINED
+#endif
+
+#if !defined(VUINT16x8_MUL_DEFINED) && defined(VUINT16x4_MUL_DEFINED)
+VEC_DOUBLE_MUL(u, 16, 8, 4)
+# define VUINT16x8_MUL_DEFINED
+#endif
+
+#if !defined(VUINT16x8_DIV_DEFINED) && defined(VUINT16x4_DIV_DEFINED)
+VEC_DOUBLE_DIV(u, 16, 8, 4)
+# define VUINT16x8_DIV_DEFINED
+#endif
+
+#if !defined(VUINT16x8_MOD_DEFINED) && defined(VUINT16x4_MOD_DEFINED)
+VEC_DOUBLE_MOD(u, 16, 8, 4)
+# define VUINT16x8_MOD_DEFINED
+#endif
+
+#if !defined(VUINT16x8_AVG_DEFINED) && defined(VUINT16x4_AVG_DEFINED)
+VEC_DOUBLE_AVG(u, 16, 8, 4)
+# define VUINT16x8_AVG_DEFINED
+#endif
+
+#if !defined(VUINT16x8_AND_DEFINED) && defined(VUINT16x4_AND_DEFINED)
+VEC_DOUBLE_AND(u, 16, 8, 4)
+# define VUINT16x8_AND_DEFINED
+#endif
+
+#if !defined(VUINT16x8_OR_DEFINED) && defined(VUINT16x4_OR_DEFINED)
+VEC_DOUBLE_OR(u, 16, 8, 4)
+# define VUINT16x8_OR_DEFINED
+#endif
+
+#if !defined(VUINT16x8_XOR_DEFINED) && defined(VUINT16x4_XOR_DEFINED)
+VEC_DOUBLE_XOR(u, 16, 8, 4)
+# define VUINT16x8_XOR_DEFINED
+#endif
+
+#if !defined(VUINT16x8_NOT_DEFINED) && defined(VUINT16x4_NOT_DEFINED)
+VEC_DOUBLE_NOT(u, 16, 8, 4)
+# define VUINT16x8_NOT_DEFINED
+#endif
+
+#if !defined(VUINT16x8_CMPLT_DEFINED) && defined(VUINT16x4_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(u, 16, 8, 4)
+# define VUINT16x8_CMPLT_DEFINED
+#endif
+
+#if !defined(VUINT16x8_CMPEQ_DEFINED) && defined(VUINT16x4_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(u, 16, 8, 4)
+# define VUINT16x8_CMPEQ_DEFINED
+#endif
+
+#if !defined(VUINT16x8_CMPGT_DEFINED) && defined(VUINT16x4_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(u, 16, 8, 4)
+# define VUINT16x8_CMPGT_DEFINED
+#endif
+
+#if !defined(VUINT16x8_CMPLE_DEFINED) && defined(VUINT16x4_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(u, 16, 8, 4)
+# define VUINT16x8_CMPLE_DEFINED
+#endif
+
+#if !defined(VUINT16x8_CMPGE_DEFINED) && defined(VUINT16x4_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(u, 16, 8, 4)
+# define VUINT16x8_CMPGE_DEFINED
+#endif
+
+#if !defined(VUINT16x8_MIN_DEFINED) && defined(VUINT16x4_MIN_DEFINED)
+VEC_DOUBLE_MIN(u, 16, 8, 4)
+# define VUINT16x8_MIN_DEFINED
+#endif
+
+#if !defined(VUINT16x8_MAX_DEFINED) && defined(VUINT16x4_MAX_DEFINED)
+VEC_DOUBLE_MAX(u, 16, 8, 4)
+# define VUINT16x8_MAX_DEFINED
+#endif
+
+#if !defined(VUINT16x8_RSHIFT_DEFINED) && defined(VUINT16x4_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(u, 16, 8, 4)
+# define VUINT16x8_RSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT16x8_LRSHIFT_DEFINED) && defined(VUINT16x4_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(u, 16, 8, 4)
+# define VUINT16x8_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT16x8_LSHIFT_DEFINED) && defined(VUINT16x4_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(u, 16, 8, 4)
+# define VUINT16x8_LSHIFT_DEFINED
+#endif
+
+
+
+/* vuint16x16 */
+
+#if !defined(VINT16x16_SPLAT_DEFINED) && defined(VINT16x8_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(/* nothing */, 16, 16, 8)
+# define VINT16x16_SPLAT_DEFINED
+#endif
+
+#if !defined(VINT16x16_LOAD_ALIGNED_DEFINED) && defined(VINT16x8_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 16, 16, 8)
+# define VINT16x16_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT16x16_LOAD_DEFINED) && defined(VINT16x8_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(/* nothing */, 16, 16, 8)
+# define VINT16x16_LOAD_DEFINED
+#endif
+
+#if !defined(VINT16x16_STORE_ALIGNED_DEFINED) && defined(VINT16x8_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 16, 16, 8)
+# define VINT16x16_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT16x16_STORE_DEFINED) && defined(VINT16x8_STORE_DEFINED)
+VEC_DOUBLE_STORE(/* nothing */, 16, 16, 8)
+# define VINT16x16_STORE_DEFINED
+#endif
+
+#if !defined(VINT16x16_ADD_DEFINED) && defined(VINT16x8_ADD_DEFINED)
+VEC_DOUBLE_ADD(/* nothing */, 16, 16, 8)
+# define VINT16x16_ADD_DEFINED
+#endif
+
+#if !defined(VINT16x16_SUB_DEFINED) && defined(VINT16x8_SUB_DEFINED)
+VEC_DOUBLE_SUB(/* nothing */, 16, 16, 8)
+# define VINT16x16_SUB_DEFINED
+#endif
+
+#if !defined(VINT16x16_MUL_DEFINED) && defined(VINT16x8_MUL_DEFINED)
+VEC_DOUBLE_MUL(/* nothing */, 16, 16, 8)
+# define VINT16x16_MUL_DEFINED
+#endif
+
+#if !defined(VINT16x16_DIV_DEFINED) && defined(VINT16x8_DIV_DEFINED)
+VEC_DOUBLE_DIV(/* nothing */, 16, 16, 8)
+# define VINT16x16_DIV_DEFINED
+#endif
+
+#if !defined(VINT16x16_MOD_DEFINED) && defined(VINT16x8_MOD_DEFINED)
+VEC_DOUBLE_MOD(/* nothing */, 16, 16, 8)
+# define VINT16x16_MOD_DEFINED
+#endif
+
+#if !defined(VINT16x16_AVG_DEFINED) && defined(VINT16x8_AVG_DEFINED)
+VEC_DOUBLE_AVG(/* nothing */, 16, 16, 8)
+# define VINT16x16_AVG_DEFINED
+#endif
+
+#if !defined(VINT16x16_AND_DEFINED) && defined(VINT16x8_AND_DEFINED)
+VEC_DOUBLE_AND(/* nothing */, 16, 16, 8)
+# define VINT16x16_AND_DEFINED
+#endif
+
+#if !defined(VINT16x16_OR_DEFINED) && defined(VINT16x8_OR_DEFINED)
+VEC_DOUBLE_OR(/* nothing */, 16, 16, 8)
+# define VINT16x16_OR_DEFINED
+#endif
+
+#if !defined(VINT16x16_XOR_DEFINED) && defined(VINT16x8_XOR_DEFINED)
+VEC_DOUBLE_XOR(/* nothing */, 16, 16, 8)
+# define VINT16x16_XOR_DEFINED
+#endif
+
+#if !defined(VINT16x16_NOT_DEFINED) && defined(VINT16x8_NOT_DEFINED)
+VEC_DOUBLE_NOT(/* nothing */, 16, 16, 8)
+# define VINT16x16_NOT_DEFINED
+#endif
+
+#if !defined(VINT16x16_CMPLT_DEFINED) && defined(VINT16x8_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(/* nothing */, 16, 16, 8)
+# define VINT16x16_CMPLT_DEFINED
+#endif
+
+#if !defined(VINT16x16_CMPEQ_DEFINED) && defined(VINT16x8_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(/* nothing */, 16, 16, 8)
+# define VINT16x16_CMPEQ_DEFINED
+#endif
+
+#if !defined(VINT16x16_CMPGT_DEFINED) && defined(VINT16x8_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(/* nothing */, 16, 16, 8)
+# define VINT16x16_CMPGT_DEFINED
+#endif
+
+#if !defined(VINT16x16_CMPLE_DEFINED) && defined(VINT16x8_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(/* nothing */, 16, 16, 8)
+# define VINT16x16_CMPLE_DEFINED
+#endif
+
+#if !defined(VINT16x16_CMPGE_DEFINED) && defined(VINT16x8_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(/* nothing */, 16, 16, 8)
+# define VINT16x16_CMPGE_DEFINED
+#endif
+
+#if !defined(VINT16x16_MIN_DEFINED) && defined(VINT16x8_MIN_DEFINED)
+VEC_DOUBLE_MIN(/* nothing */, 16, 16, 8)
+# define VINT16x16_MIN_DEFINED
+#endif
+
+#if !defined(VINT16x16_MAX_DEFINED) && defined(VINT16x8_MAX_DEFINED)
+VEC_DOUBLE_MAX(/* nothing */, 16, 16, 8)
+# define VINT16x16_MAX_DEFINED
+#endif
+
+#if !defined(VINT16x16_RSHIFT_DEFINED) && defined(VINT16x8_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(/* nothing */, 16, 16, 8)
+# define VINT16x16_RSHIFT_DEFINED
+#endif
+
+#if !defined(VINT16x16_LRSHIFT_DEFINED) && defined(VINT16x8_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(/* nothing */, 16, 16, 8)
+# define VINT16x16_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VINT16x16_LSHIFT_DEFINED) && defined(VINT16x8_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(/* nothing */, 16, 16, 8)
+# define VINT16x16_LSHIFT_DEFINED
+#endif
+
+
+
+/* vint16x16 */
+
+#if !defined(VUINT16x16_SPLAT_DEFINED) && defined(VUINT16x8_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(u, 16, 16, 8)
+# define VUINT16x16_SPLAT_DEFINED
+#endif
+
+#if !defined(VUINT16x16_LOAD_ALIGNED_DEFINED) && defined(VUINT16x8_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(u, 16, 16, 8)
+# define VUINT16x16_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT16x16_LOAD_DEFINED) && defined(VUINT16x8_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(u, 16, 16, 8)
+# define VUINT16x16_LOAD_DEFINED
+#endif
+
+#if !defined(VUINT16x16_STORE_ALIGNED_DEFINED) && defined(VUINT16x8_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(u, 16, 16, 8)
+# define VUINT16x16_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT16x16_STORE_DEFINED) && defined(VUINT16x8_STORE_DEFINED)
+VEC_DOUBLE_STORE(u, 16, 16, 8)
+# define VUINT16x16_STORE_DEFINED
+#endif
+
+#if !defined(VUINT16x16_ADD_DEFINED) && defined(VUINT16x8_ADD_DEFINED)
+VEC_DOUBLE_ADD(u, 16, 16, 8)
+# define VUINT16x16_ADD_DEFINED
+#endif
+
+#if !defined(VUINT16x16_SUB_DEFINED) && defined(VUINT16x8_SUB_DEFINED)
+VEC_DOUBLE_SUB(u, 16, 16, 8)
+# define VUINT16x16_SUB_DEFINED
+#endif
+
+#if !defined(VUINT16x16_MUL_DEFINED) && defined(VUINT16x8_MUL_DEFINED)
+VEC_DOUBLE_MUL(u, 16, 16, 8)
+# define VUINT16x16_MUL_DEFINED
+#endif
+
+#if !defined(VUINT16x16_DIV_DEFINED) && defined(VUINT16x8_DIV_DEFINED)
+VEC_DOUBLE_DIV(u, 16, 16, 8)
+# define VUINT16x16_DIV_DEFINED
+#endif
+
+#if !defined(VUINT16x16_MOD_DEFINED) && defined(VUINT16x8_MOD_DEFINED)
+VEC_DOUBLE_MOD(u, 16, 16, 8)
+# define VUINT16x16_MOD_DEFINED
+#endif
+
+#if !defined(VUINT16x16_AVG_DEFINED) && defined(VUINT16x8_AVG_DEFINED)
+VEC_DOUBLE_AVG(u, 16, 16, 8)
+# define VUINT16x16_AVG_DEFINED
+#endif
+
+#if !defined(VUINT16x16_AND_DEFINED) && defined(VUINT16x8_AND_DEFINED)
+VEC_DOUBLE_AND(u, 16, 16, 8)
+# define VUINT16x16_AND_DEFINED
+#endif
+
+#if !defined(VUINT16x16_OR_DEFINED) && defined(VUINT16x8_OR_DEFINED)
+VEC_DOUBLE_OR(u, 16, 16, 8)
+# define VUINT16x16_OR_DEFINED
+#endif
+
+#if !defined(VUINT16x16_XOR_DEFINED) && defined(VUINT16x8_XOR_DEFINED)
+VEC_DOUBLE_XOR(u, 16, 16, 8)
+# define VUINT16x16_XOR_DEFINED
+#endif
+
+#if !defined(VUINT16x16_NOT_DEFINED) && defined(VUINT16x8_NOT_DEFINED)
+VEC_DOUBLE_NOT(u, 16, 16, 8)
+# define VUINT16x16_NOT_DEFINED
+#endif
+
+#if !defined(VUINT16x16_CMPLT_DEFINED) && defined(VUINT16x8_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(u, 16, 16, 8)
+# define VUINT16x16_CMPLT_DEFINED
+#endif
+
+#if !defined(VUINT16x16_CMPEQ_DEFINED) && defined(VUINT16x8_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(u, 16, 16, 8)
+# define VUINT16x16_CMPEQ_DEFINED
+#endif
+
+#if !defined(VUINT16x16_CMPGT_DEFINED) && defined(VUINT16x8_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(u, 16, 16, 8)
+# define VUINT16x16_CMPGT_DEFINED
+#endif
+
+#if !defined(VUINT16x16_CMPLE_DEFINED) && defined(VUINT16x8_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(u, 16, 16, 8)
+# define VUINT16x16_CMPLE_DEFINED
+#endif
+
+#if !defined(VUINT16x16_CMPGE_DEFINED) && defined(VUINT16x8_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(u, 16, 16, 8)
+# define VUINT16x16_CMPGE_DEFINED
+#endif
+
+#if !defined(VUINT16x16_MIN_DEFINED) && defined(VUINT16x8_MIN_DEFINED)
+VEC_DOUBLE_MIN(u, 16, 16, 8)
+# define VUINT16x16_MIN_DEFINED
+#endif
+
+#if !defined(VUINT16x16_MAX_DEFINED) && defined(VUINT16x8_MAX_DEFINED)
+VEC_DOUBLE_MAX(u, 16, 16, 8)
+# define VUINT16x16_MAX_DEFINED
+#endif
+
+#if !defined(VUINT16x16_RSHIFT_DEFINED) && defined(VUINT16x8_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(u, 16, 16, 8)
+# define VUINT16x16_RSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT16x16_LRSHIFT_DEFINED) && defined(VUINT16x8_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(u, 16, 16, 8)
+# define VUINT16x16_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT16x16_LSHIFT_DEFINED) && defined(VUINT16x8_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(u, 16, 16, 8)
+# define VUINT16x16_LSHIFT_DEFINED
+#endif
+
+
+
+/* vuint16x32 */
+
+#if !defined(VINT16x32_SPLAT_DEFINED) && defined(VINT16x16_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(/* nothing */, 16, 32, 16)
+# define VINT16x32_SPLAT_DEFINED
+#endif
+
+#if !defined(VINT16x32_LOAD_ALIGNED_DEFINED) && defined(VINT16x16_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 16, 32, 16)
+# define VINT16x32_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT16x32_LOAD_DEFINED) && defined(VINT16x16_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(/* nothing */, 16, 32, 16)
+# define VINT16x32_LOAD_DEFINED
+#endif
+
+#if !defined(VINT16x32_STORE_ALIGNED_DEFINED) && defined(VINT16x16_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 16, 32, 16)
+# define VINT16x32_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT16x32_STORE_DEFINED) && defined(VINT16x16_STORE_DEFINED)
+VEC_DOUBLE_STORE(/* nothing */, 16, 32, 16)
+# define VINT16x32_STORE_DEFINED
+#endif
+
+#if !defined(VINT16x32_ADD_DEFINED) && defined(VINT16x16_ADD_DEFINED)
+VEC_DOUBLE_ADD(/* nothing */, 16, 32, 16)
+# define VINT16x32_ADD_DEFINED
+#endif
+
+#if !defined(VINT16x32_SUB_DEFINED) && defined(VINT16x16_SUB_DEFINED)
+VEC_DOUBLE_SUB(/* nothing */, 16, 32, 16)
+# define VINT16x32_SUB_DEFINED
+#endif
+
+#if !defined(VINT16x32_MUL_DEFINED) && defined(VINT16x16_MUL_DEFINED)
+VEC_DOUBLE_MUL(/* nothing */, 16, 32, 16)
+# define VINT16x32_MUL_DEFINED
+#endif
+
+#if !defined(VINT16x32_DIV_DEFINED) && defined(VINT16x16_DIV_DEFINED)
+VEC_DOUBLE_DIV(/* nothing */, 16, 32, 16)
+# define VINT16x32_DIV_DEFINED
+#endif
+
+#if !defined(VINT16x32_MOD_DEFINED) && defined(VINT16x16_MOD_DEFINED)
+VEC_DOUBLE_MOD(/* nothing */, 16, 32, 16)
+# define VINT16x32_MOD_DEFINED
+#endif
+
+#if !defined(VINT16x32_AVG_DEFINED) && defined(VINT16x16_AVG_DEFINED)
+VEC_DOUBLE_AVG(/* nothing */, 16, 32, 16)
+# define VINT16x32_AVG_DEFINED
+#endif
+
+#if !defined(VINT16x32_AND_DEFINED) && defined(VINT16x16_AND_DEFINED)
+VEC_DOUBLE_AND(/* nothing */, 16, 32, 16)
+# define VINT16x32_AND_DEFINED
+#endif
+
+#if !defined(VINT16x32_OR_DEFINED) && defined(VINT16x16_OR_DEFINED)
+VEC_DOUBLE_OR(/* nothing */, 16, 32, 16)
+# define VINT16x32_OR_DEFINED
+#endif
+
+#if !defined(VINT16x32_XOR_DEFINED) && defined(VINT16x16_XOR_DEFINED)
+VEC_DOUBLE_XOR(/* nothing */, 16, 32, 16)
+# define VINT16x32_XOR_DEFINED
+#endif
+
+#if !defined(VINT16x32_NOT_DEFINED) && defined(VINT16x16_NOT_DEFINED)
+VEC_DOUBLE_NOT(/* nothing */, 16, 32, 16)
+# define VINT16x32_NOT_DEFINED
+#endif
+
+#if !defined(VINT16x32_CMPLT_DEFINED) && defined(VINT16x16_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(/* nothing */, 16, 32, 16)
+# define VINT16x32_CMPLT_DEFINED
+#endif
+
+#if !defined(VINT16x32_CMPEQ_DEFINED) && defined(VINT16x16_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(/* nothing */, 16, 32, 16)
+# define VINT16x32_CMPEQ_DEFINED
+#endif
+
+#if !defined(VINT16x32_CMPGT_DEFINED) && defined(VINT16x16_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(/* nothing */, 16, 32, 16)
+# define VINT16x32_CMPGT_DEFINED
+#endif
+
+#if !defined(VINT16x32_CMPLE_DEFINED) && defined(VINT16x16_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(/* nothing */, 16, 32, 16)
+# define VINT16x32_CMPLE_DEFINED
+#endif
+
+#if !defined(VINT16x32_CMPGE_DEFINED) && defined(VINT16x16_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(/* nothing */, 16, 32, 16)
+# define VINT16x32_CMPGE_DEFINED
+#endif
+
+#if !defined(VINT16x32_MIN_DEFINED) && defined(VINT16x16_MIN_DEFINED)
+VEC_DOUBLE_MIN(/* nothing */, 16, 32, 16)
+# define VINT16x32_MIN_DEFINED
+#endif
+
+#if !defined(VINT16x32_MAX_DEFINED) && defined(VINT16x16_MAX_DEFINED)
+VEC_DOUBLE_MAX(/* nothing */, 16, 32, 16)
+# define VINT16x32_MAX_DEFINED
+#endif
+
+#if !defined(VINT16x32_RSHIFT_DEFINED) && defined(VINT16x16_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(/* nothing */, 16, 32, 16)
+# define VINT16x32_RSHIFT_DEFINED
+#endif
+
+#if !defined(VINT16x32_LRSHIFT_DEFINED) && defined(VINT16x16_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(/* nothing */, 16, 32, 16)
+# define VINT16x32_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VINT16x32_LSHIFT_DEFINED) && defined(VINT16x16_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(/* nothing */, 16, 32, 16)
+# define VINT16x32_LSHIFT_DEFINED
+#endif
+
+
+
+/* vint16x32 */
+
+#if !defined(VUINT16x32_SPLAT_DEFINED) && defined(VUINT16x16_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(u, 16, 32, 16)
+# define VUINT16x32_SPLAT_DEFINED
+#endif
+
+#if !defined(VUINT16x32_LOAD_ALIGNED_DEFINED) && defined(VUINT16x16_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(u, 16, 32, 16)
+# define VUINT16x32_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT16x32_LOAD_DEFINED) && defined(VUINT16x16_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(u, 16, 32, 16)
+# define VUINT16x32_LOAD_DEFINED
+#endif
+
+#if !defined(VUINT16x32_STORE_ALIGNED_DEFINED) && defined(VUINT16x16_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(u, 16, 32, 16)
+# define VUINT16x32_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT16x32_STORE_DEFINED) && defined(VUINT16x16_STORE_DEFINED)
+VEC_DOUBLE_STORE(u, 16, 32, 16)
+# define VUINT16x32_STORE_DEFINED
+#endif
+
+#if !defined(VUINT16x32_ADD_DEFINED) && defined(VUINT16x16_ADD_DEFINED)
+VEC_DOUBLE_ADD(u, 16, 32, 16)
+# define VUINT16x32_ADD_DEFINED
+#endif
+
+#if !defined(VUINT16x32_SUB_DEFINED) && defined(VUINT16x16_SUB_DEFINED)
+VEC_DOUBLE_SUB(u, 16, 32, 16)
+# define VUINT16x32_SUB_DEFINED
+#endif
+
+#if !defined(VUINT16x32_MUL_DEFINED) && defined(VUINT16x16_MUL_DEFINED)
+VEC_DOUBLE_MUL(u, 16, 32, 16)
+# define VUINT16x32_MUL_DEFINED
+#endif
+
+#if !defined(VUINT16x32_DIV_DEFINED) && defined(VUINT16x16_DIV_DEFINED)
+VEC_DOUBLE_DIV(u, 16, 32, 16)
+# define VUINT16x32_DIV_DEFINED
+#endif
+
+#if !defined(VUINT16x32_MOD_DEFINED) && defined(VUINT16x16_MOD_DEFINED)
+VEC_DOUBLE_MOD(u, 16, 32, 16)
+# define VUINT16x32_MOD_DEFINED
+#endif
+
+#if !defined(VUINT16x32_AVG_DEFINED) && defined(VUINT16x16_AVG_DEFINED)
+VEC_DOUBLE_AVG(u, 16, 32, 16)
+# define VUINT16x32_AVG_DEFINED
+#endif
+
+#if !defined(VUINT16x32_AND_DEFINED) && defined(VUINT16x16_AND_DEFINED)
+VEC_DOUBLE_AND(u, 16, 32, 16)
+# define VUINT16x32_AND_DEFINED
+#endif
+
+#if !defined(VUINT16x32_OR_DEFINED) && defined(VUINT16x16_OR_DEFINED)
+VEC_DOUBLE_OR(u, 16, 32, 16)
+# define VUINT16x32_OR_DEFINED
+#endif
+
+#if !defined(VUINT16x32_XOR_DEFINED) && defined(VUINT16x16_XOR_DEFINED)
+VEC_DOUBLE_XOR(u, 16, 32, 16)
+# define VUINT16x32_XOR_DEFINED
+#endif
+
+#if !defined(VUINT16x32_NOT_DEFINED) && defined(VUINT16x16_NOT_DEFINED)
+VEC_DOUBLE_NOT(u, 16, 32, 16)
+# define VUINT16x32_NOT_DEFINED
+#endif
+
+#if !defined(VUINT16x32_CMPLT_DEFINED) && defined(VUINT16x16_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(u, 16, 32, 16)
+# define VUINT16x32_CMPLT_DEFINED
+#endif
+
+#if !defined(VUINT16x32_CMPEQ_DEFINED) && defined(VUINT16x16_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(u, 16, 32, 16)
+# define VUINT16x32_CMPEQ_DEFINED
+#endif
+
+#if !defined(VUINT16x32_CMPGT_DEFINED) && defined(VUINT16x16_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(u, 16, 32, 16)
+# define VUINT16x32_CMPGT_DEFINED
+#endif
+
+#if !defined(VUINT16x32_CMPLE_DEFINED) && defined(VUINT16x16_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(u, 16, 32, 16)
+# define VUINT16x32_CMPLE_DEFINED
+#endif
+
+#if !defined(VUINT16x32_CMPGE_DEFINED) && defined(VUINT16x16_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(u, 16, 32, 16)
+# define VUINT16x32_CMPGE_DEFINED
+#endif
+
+#if !defined(VUINT16x32_MIN_DEFINED) && defined(VUINT16x16_MIN_DEFINED)
+VEC_DOUBLE_MIN(u, 16, 32, 16)
+# define VUINT16x32_MIN_DEFINED
+#endif
+
+#if !defined(VUINT16x32_MAX_DEFINED) && defined(VUINT16x16_MAX_DEFINED)
+VEC_DOUBLE_MAX(u, 16, 32, 16)
+# define VUINT16x32_MAX_DEFINED
+#endif
+
+#if !defined(VUINT16x32_RSHIFT_DEFINED) && defined(VUINT16x16_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(u, 16, 32, 16)
+# define VUINT16x32_RSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT16x32_LRSHIFT_DEFINED) && defined(VUINT16x16_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(u, 16, 32, 16)
+# define VUINT16x32_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT16x32_LSHIFT_DEFINED) && defined(VUINT16x16_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(u, 16, 32, 16)
+# define VUINT16x32_LSHIFT_DEFINED
+#endif
+
+
+
+/* vuint32x4 */
+
+#if !defined(VINT32x4_SPLAT_DEFINED) && defined(VINT32x2_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(/* nothing */, 32, 4, 2)
+# define VINT32x4_SPLAT_DEFINED
+#endif
+
+#if !defined(VINT32x4_LOAD_ALIGNED_DEFINED) && defined(VINT32x2_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 32, 4, 2)
+# define VINT32x4_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT32x4_LOAD_DEFINED) && defined(VINT32x2_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(/* nothing */, 32, 4, 2)
+# define VINT32x4_LOAD_DEFINED
+#endif
+
+#if !defined(VINT32x4_STORE_ALIGNED_DEFINED) && defined(VINT32x2_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 32, 4, 2)
+# define VINT32x4_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT32x4_STORE_DEFINED) && defined(VINT32x2_STORE_DEFINED)
+VEC_DOUBLE_STORE(/* nothing */, 32, 4, 2)
+# define VINT32x4_STORE_DEFINED
+#endif
+
+#if !defined(VINT32x4_ADD_DEFINED) && defined(VINT32x2_ADD_DEFINED)
+VEC_DOUBLE_ADD(/* nothing */, 32, 4, 2)
+# define VINT32x4_ADD_DEFINED
+#endif
+
+#if !defined(VINT32x4_SUB_DEFINED) && defined(VINT32x2_SUB_DEFINED)
+VEC_DOUBLE_SUB(/* nothing */, 32, 4, 2)
+# define VINT32x4_SUB_DEFINED
+#endif
+
+#if !defined(VINT32x4_MUL_DEFINED) && defined(VINT32x2_MUL_DEFINED)
+VEC_DOUBLE_MUL(/* nothing */, 32, 4, 2)
+# define VINT32x4_MUL_DEFINED
+#endif
+
+#if !defined(VINT32x4_DIV_DEFINED) && defined(VINT32x2_DIV_DEFINED)
+VEC_DOUBLE_DIV(/* nothing */, 32, 4, 2)
+# define VINT32x4_DIV_DEFINED
+#endif
+
+#if !defined(VINT32x4_MOD_DEFINED) && defined(VINT32x2_MOD_DEFINED)
+VEC_DOUBLE_MOD(/* nothing */, 32, 4, 2)
+# define VINT32x4_MOD_DEFINED
+#endif
+
+#if !defined(VINT32x4_AVG_DEFINED) && defined(VINT32x2_AVG_DEFINED)
+VEC_DOUBLE_AVG(/* nothing */, 32, 4, 2)
+# define VINT32x4_AVG_DEFINED
+#endif
+
+#if !defined(VINT32x4_AND_DEFINED) && defined(VINT32x2_AND_DEFINED)
+VEC_DOUBLE_AND(/* nothing */, 32, 4, 2)
+# define VINT32x4_AND_DEFINED
+#endif
+
+#if !defined(VINT32x4_OR_DEFINED) && defined(VINT32x2_OR_DEFINED)
+VEC_DOUBLE_OR(/* nothing */, 32, 4, 2)
+# define VINT32x4_OR_DEFINED
+#endif
+
+#if !defined(VINT32x4_XOR_DEFINED) && defined(VINT32x2_XOR_DEFINED)
+VEC_DOUBLE_XOR(/* nothing */, 32, 4, 2)
+# define VINT32x4_XOR_DEFINED
+#endif
+
+#if !defined(VINT32x4_NOT_DEFINED) && defined(VINT32x2_NOT_DEFINED)
+VEC_DOUBLE_NOT(/* nothing */, 32, 4, 2)
+# define VINT32x4_NOT_DEFINED
+#endif
+
+#if !defined(VINT32x4_CMPLT_DEFINED) && defined(VINT32x2_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(/* nothing */, 32, 4, 2)
+# define VINT32x4_CMPLT_DEFINED
+#endif
+
+#if !defined(VINT32x4_CMPEQ_DEFINED) && defined(VINT32x2_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(/* nothing */, 32, 4, 2)
+# define VINT32x4_CMPEQ_DEFINED
+#endif
+
+#if !defined(VINT32x4_CMPGT_DEFINED) && defined(VINT32x2_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(/* nothing */, 32, 4, 2)
+# define VINT32x4_CMPGT_DEFINED
+#endif
+
+#if !defined(VINT32x4_CMPLE_DEFINED) && defined(VINT32x2_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(/* nothing */, 32, 4, 2)
+# define VINT32x4_CMPLE_DEFINED
+#endif
+
+#if !defined(VINT32x4_CMPGE_DEFINED) && defined(VINT32x2_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(/* nothing */, 32, 4, 2)
+# define VINT32x4_CMPGE_DEFINED
+#endif
+
+#if !defined(VINT32x4_MIN_DEFINED) && defined(VINT32x2_MIN_DEFINED)
+VEC_DOUBLE_MIN(/* nothing */, 32, 4, 2)
+# define VINT32x4_MIN_DEFINED
+#endif
+
+#if !defined(VINT32x4_MAX_DEFINED) && defined(VINT32x2_MAX_DEFINED)
+VEC_DOUBLE_MAX(/* nothing */, 32, 4, 2)
+# define VINT32x4_MAX_DEFINED
+#endif
+
+#if !defined(VINT32x4_RSHIFT_DEFINED) && defined(VINT32x2_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(/* nothing */, 32, 4, 2)
+# define VINT32x4_RSHIFT_DEFINED
+#endif
+
+#if !defined(VINT32x4_LRSHIFT_DEFINED) && defined(VINT32x2_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(/* nothing */, 32, 4, 2)
+# define VINT32x4_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VINT32x4_LSHIFT_DEFINED) && defined(VINT32x2_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(/* nothing */, 32, 4, 2)
+# define VINT32x4_LSHIFT_DEFINED
+#endif
+
+
+
+/* vint32x4 */
+
+#if !defined(VUINT32x4_SPLAT_DEFINED) && defined(VUINT32x2_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(u, 32, 4, 2)
+# define VUINT32x4_SPLAT_DEFINED
+#endif
+
+#if !defined(VUINT32x4_LOAD_ALIGNED_DEFINED) && defined(VUINT32x2_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(u, 32, 4, 2)
+# define VUINT32x4_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT32x4_LOAD_DEFINED) && defined(VUINT32x2_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(u, 32, 4, 2)
+# define VUINT32x4_LOAD_DEFINED
+#endif
+
+#if !defined(VUINT32x4_STORE_ALIGNED_DEFINED) && defined(VUINT32x2_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(u, 32, 4, 2)
+# define VUINT32x4_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT32x4_STORE_DEFINED) && defined(VUINT32x2_STORE_DEFINED)
+VEC_DOUBLE_STORE(u, 32, 4, 2)
+# define VUINT32x4_STORE_DEFINED
+#endif
+
+#if !defined(VUINT32x4_ADD_DEFINED) && defined(VUINT32x2_ADD_DEFINED)
+VEC_DOUBLE_ADD(u, 32, 4, 2)
+# define VUINT32x4_ADD_DEFINED
+#endif
+
+#if !defined(VUINT32x4_SUB_DEFINED) && defined(VUINT32x2_SUB_DEFINED)
+VEC_DOUBLE_SUB(u, 32, 4, 2)
+# define VUINT32x4_SUB_DEFINED
+#endif
+
+#if !defined(VUINT32x4_MUL_DEFINED) && defined(VUINT32x2_MUL_DEFINED)
+VEC_DOUBLE_MUL(u, 32, 4, 2)
+# define VUINT32x4_MUL_DEFINED
+#endif
+
+#if !defined(VUINT32x4_DIV_DEFINED) && defined(VUINT32x2_DIV_DEFINED)
+VEC_DOUBLE_DIV(u, 32, 4, 2)
+# define VUINT32x4_DIV_DEFINED
+#endif
+
+#if !defined(VUINT32x4_MOD_DEFINED) && defined(VUINT32x2_MOD_DEFINED)
+VEC_DOUBLE_MOD(u, 32, 4, 2)
+# define VUINT32x4_MOD_DEFINED
+#endif
+
+#if !defined(VUINT32x4_AVG_DEFINED) && defined(VUINT32x2_AVG_DEFINED)
+VEC_DOUBLE_AVG(u, 32, 4, 2)
+# define VUINT32x4_AVG_DEFINED
+#endif
+
+#if !defined(VUINT32x4_AND_DEFINED) && defined(VUINT32x2_AND_DEFINED)
+VEC_DOUBLE_AND(u, 32, 4, 2)
+# define VUINT32x4_AND_DEFINED
+#endif
+
+#if !defined(VUINT32x4_OR_DEFINED) && defined(VUINT32x2_OR_DEFINED)
+VEC_DOUBLE_OR(u, 32, 4, 2)
+# define VUINT32x4_OR_DEFINED
+#endif
+
+#if !defined(VUINT32x4_XOR_DEFINED) && defined(VUINT32x2_XOR_DEFINED)
+VEC_DOUBLE_XOR(u, 32, 4, 2)
+# define VUINT32x4_XOR_DEFINED
+#endif
+
+#if !defined(VUINT32x4_NOT_DEFINED) && defined(VUINT32x2_NOT_DEFINED)
+VEC_DOUBLE_NOT(u, 32, 4, 2)
+# define VUINT32x4_NOT_DEFINED
+#endif
+
+#if !defined(VUINT32x4_CMPLT_DEFINED) && defined(VUINT32x2_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(u, 32, 4, 2)
+# define VUINT32x4_CMPLT_DEFINED
+#endif
+
+#if !defined(VUINT32x4_CMPEQ_DEFINED) && defined(VUINT32x2_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(u, 32, 4, 2)
+# define VUINT32x4_CMPEQ_DEFINED
+#endif
+
+#if !defined(VUINT32x4_CMPGT_DEFINED) && defined(VUINT32x2_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(u, 32, 4, 2)
+# define VUINT32x4_CMPGT_DEFINED
+#endif
+
+#if !defined(VUINT32x4_CMPLE_DEFINED) && defined(VUINT32x2_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(u, 32, 4, 2)
+# define VUINT32x4_CMPLE_DEFINED
+#endif
+
+#if !defined(VUINT32x4_CMPGE_DEFINED) && defined(VUINT32x2_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(u, 32, 4, 2)
+# define VUINT32x4_CMPGE_DEFINED
+#endif
+
+#if !defined(VUINT32x4_MIN_DEFINED) && defined(VUINT32x2_MIN_DEFINED)
+VEC_DOUBLE_MIN(u, 32, 4, 2)
+# define VUINT32x4_MIN_DEFINED
+#endif
+
+#if !defined(VUINT32x4_MAX_DEFINED) && defined(VUINT32x2_MAX_DEFINED)
+VEC_DOUBLE_MAX(u, 32, 4, 2)
+# define VUINT32x4_MAX_DEFINED
+#endif
+
+#if !defined(VUINT32x4_RSHIFT_DEFINED) && defined(VUINT32x2_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(u, 32, 4, 2)
+# define VUINT32x4_RSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT32x4_LRSHIFT_DEFINED) && defined(VUINT32x2_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(u, 32, 4, 2)
+# define VUINT32x4_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT32x4_LSHIFT_DEFINED) && defined(VUINT32x2_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(u, 32, 4, 2)
+# define VUINT32x4_LSHIFT_DEFINED
+#endif
+
+
+
+/* vuint32x8 */
+
+#if !defined(VINT32x8_SPLAT_DEFINED) && defined(VINT32x4_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(/* nothing */, 32, 8, 4)
+# define VINT32x8_SPLAT_DEFINED
+#endif
+
+#if !defined(VINT32x8_LOAD_ALIGNED_DEFINED) && defined(VINT32x4_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 32, 8, 4)
+# define VINT32x8_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT32x8_LOAD_DEFINED) && defined(VINT32x4_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(/* nothing */, 32, 8, 4)
+# define VINT32x8_LOAD_DEFINED
+#endif
+
+#if !defined(VINT32x8_STORE_ALIGNED_DEFINED) && defined(VINT32x4_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 32, 8, 4)
+# define VINT32x8_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT32x8_STORE_DEFINED) && defined(VINT32x4_STORE_DEFINED)
+VEC_DOUBLE_STORE(/* nothing */, 32, 8, 4)
+# define VINT32x8_STORE_DEFINED
+#endif
+
+#if !defined(VINT32x8_ADD_DEFINED) && defined(VINT32x4_ADD_DEFINED)
+VEC_DOUBLE_ADD(/* nothing */, 32, 8, 4)
+# define VINT32x8_ADD_DEFINED
+#endif
+
+#if !defined(VINT32x8_SUB_DEFINED) && defined(VINT32x4_SUB_DEFINED)
+VEC_DOUBLE_SUB(/* nothing */, 32, 8, 4)
+# define VINT32x8_SUB_DEFINED
+#endif
+
+#if !defined(VINT32x8_MUL_DEFINED) && defined(VINT32x4_MUL_DEFINED)
+VEC_DOUBLE_MUL(/* nothing */, 32, 8, 4)
+# define VINT32x8_MUL_DEFINED
+#endif
+
+#if !defined(VINT32x8_DIV_DEFINED) && defined(VINT32x4_DIV_DEFINED)
+VEC_DOUBLE_DIV(/* nothing */, 32, 8, 4)
+# define VINT32x8_DIV_DEFINED
+#endif
+
+#if !defined(VINT32x8_MOD_DEFINED) && defined(VINT32x4_MOD_DEFINED)
+VEC_DOUBLE_MOD(/* nothing */, 32, 8, 4)
+# define VINT32x8_MOD_DEFINED
+#endif
+
+#if !defined(VINT32x8_AVG_DEFINED) && defined(VINT32x4_AVG_DEFINED)
+VEC_DOUBLE_AVG(/* nothing */, 32, 8, 4)
+# define VINT32x8_AVG_DEFINED
+#endif
+
+#if !defined(VINT32x8_AND_DEFINED) && defined(VINT32x4_AND_DEFINED)
+VEC_DOUBLE_AND(/* nothing */, 32, 8, 4)
+# define VINT32x8_AND_DEFINED
+#endif
+
+#if !defined(VINT32x8_OR_DEFINED) && defined(VINT32x4_OR_DEFINED)
+VEC_DOUBLE_OR(/* nothing */, 32, 8, 4)
+# define VINT32x8_OR_DEFINED
+#endif
+
+#if !defined(VINT32x8_XOR_DEFINED) && defined(VINT32x4_XOR_DEFINED)
+VEC_DOUBLE_XOR(/* nothing */, 32, 8, 4)
+# define VINT32x8_XOR_DEFINED
+#endif
+
+#if !defined(VINT32x8_NOT_DEFINED) && defined(VINT32x4_NOT_DEFINED)
+VEC_DOUBLE_NOT(/* nothing */, 32, 8, 4)
+# define VINT32x8_NOT_DEFINED
+#endif
+
+#if !defined(VINT32x8_CMPLT_DEFINED) && defined(VINT32x4_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(/* nothing */, 32, 8, 4)
+# define VINT32x8_CMPLT_DEFINED
+#endif
+
+#if !defined(VINT32x8_CMPEQ_DEFINED) && defined(VINT32x4_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(/* nothing */, 32, 8, 4)
+# define VINT32x8_CMPEQ_DEFINED
+#endif
+
+#if !defined(VINT32x8_CMPGT_DEFINED) && defined(VINT32x4_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(/* nothing */, 32, 8, 4)
+# define VINT32x8_CMPGT_DEFINED
+#endif
+
+#if !defined(VINT32x8_CMPLE_DEFINED) && defined(VINT32x4_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(/* nothing */, 32, 8, 4)
+# define VINT32x8_CMPLE_DEFINED
+#endif
+
+#if !defined(VINT32x8_CMPGE_DEFINED) && defined(VINT32x4_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(/* nothing */, 32, 8, 4)
+# define VINT32x8_CMPGE_DEFINED
+#endif
+
+#if !defined(VINT32x8_MIN_DEFINED) && defined(VINT32x4_MIN_DEFINED)
+VEC_DOUBLE_MIN(/* nothing */, 32, 8, 4)
+# define VINT32x8_MIN_DEFINED
+#endif
+
+#if !defined(VINT32x8_MAX_DEFINED) && defined(VINT32x4_MAX_DEFINED)
+VEC_DOUBLE_MAX(/* nothing */, 32, 8, 4)
+# define VINT32x8_MAX_DEFINED
+#endif
+
+#if !defined(VINT32x8_RSHIFT_DEFINED) && defined(VINT32x4_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(/* nothing */, 32, 8, 4)
+# define VINT32x8_RSHIFT_DEFINED
+#endif
+
+#if !defined(VINT32x8_LRSHIFT_DEFINED) && defined(VINT32x4_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(/* nothing */, 32, 8, 4)
+# define VINT32x8_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VINT32x8_LSHIFT_DEFINED) && defined(VINT32x4_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(/* nothing */, 32, 8, 4)
+# define VINT32x8_LSHIFT_DEFINED
+#endif
+
+
+
+/* vint32x8 */
+
+#if !defined(VUINT32x8_SPLAT_DEFINED) && defined(VUINT32x4_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(u, 32, 8, 4)
+# define VUINT32x8_SPLAT_DEFINED
+#endif
+
+#if !defined(VUINT32x8_LOAD_ALIGNED_DEFINED) && defined(VUINT32x4_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(u, 32, 8, 4)
+# define VUINT32x8_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT32x8_LOAD_DEFINED) && defined(VUINT32x4_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(u, 32, 8, 4)
+# define VUINT32x8_LOAD_DEFINED
+#endif
+
+#if !defined(VUINT32x8_STORE_ALIGNED_DEFINED) && defined(VUINT32x4_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(u, 32, 8, 4)
+# define VUINT32x8_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT32x8_STORE_DEFINED) && defined(VUINT32x4_STORE_DEFINED)
+VEC_DOUBLE_STORE(u, 32, 8, 4)
+# define VUINT32x8_STORE_DEFINED
+#endif
+
+#if !defined(VUINT32x8_ADD_DEFINED) && defined(VUINT32x4_ADD_DEFINED)
+VEC_DOUBLE_ADD(u, 32, 8, 4)
+# define VUINT32x8_ADD_DEFINED
+#endif
+
+#if !defined(VUINT32x8_SUB_DEFINED) && defined(VUINT32x4_SUB_DEFINED)
+VEC_DOUBLE_SUB(u, 32, 8, 4)
+# define VUINT32x8_SUB_DEFINED
+#endif
+
+#if !defined(VUINT32x8_MUL_DEFINED) && defined(VUINT32x4_MUL_DEFINED)
+VEC_DOUBLE_MUL(u, 32, 8, 4)
+# define VUINT32x8_MUL_DEFINED
+#endif
+
+#if !defined(VUINT32x8_DIV_DEFINED) && defined(VUINT32x4_DIV_DEFINED)
+VEC_DOUBLE_DIV(u, 32, 8, 4)
+# define VUINT32x8_DIV_DEFINED
+#endif
+
+#if !defined(VUINT32x8_MOD_DEFINED) && defined(VUINT32x4_MOD_DEFINED)
+VEC_DOUBLE_MOD(u, 32, 8, 4)
+# define VUINT32x8_MOD_DEFINED
+#endif
+
+#if !defined(VUINT32x8_AVG_DEFINED) && defined(VUINT32x4_AVG_DEFINED)
+VEC_DOUBLE_AVG(u, 32, 8, 4)
+# define VUINT32x8_AVG_DEFINED
+#endif
+
+#if !defined(VUINT32x8_AND_DEFINED) && defined(VUINT32x4_AND_DEFINED)
+VEC_DOUBLE_AND(u, 32, 8, 4)
+# define VUINT32x8_AND_DEFINED
+#endif
+
+#if !defined(VUINT32x8_OR_DEFINED) && defined(VUINT32x4_OR_DEFINED)
+VEC_DOUBLE_OR(u, 32, 8, 4)
+# define VUINT32x8_OR_DEFINED
+#endif
+
+#if !defined(VUINT32x8_XOR_DEFINED) && defined(VUINT32x4_XOR_DEFINED)
+VEC_DOUBLE_XOR(u, 32, 8, 4)
+# define VUINT32x8_XOR_DEFINED
+#endif
+
+#if !defined(VUINT32x8_NOT_DEFINED) && defined(VUINT32x4_NOT_DEFINED)
+VEC_DOUBLE_NOT(u, 32, 8, 4)
+# define VUINT32x8_NOT_DEFINED
+#endif
+
+#if !defined(VUINT32x8_CMPLT_DEFINED) && defined(VUINT32x4_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(u, 32, 8, 4)
+# define VUINT32x8_CMPLT_DEFINED
+#endif
+
+#if !defined(VUINT32x8_CMPEQ_DEFINED) && defined(VUINT32x4_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(u, 32, 8, 4)
+# define VUINT32x8_CMPEQ_DEFINED
+#endif
+
+#if !defined(VUINT32x8_CMPGT_DEFINED) && defined(VUINT32x4_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(u, 32, 8, 4)
+# define VUINT32x8_CMPGT_DEFINED
+#endif
+
+#if !defined(VUINT32x8_CMPLE_DEFINED) && defined(VUINT32x4_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(u, 32, 8, 4)
+# define VUINT32x8_CMPLE_DEFINED
+#endif
+
+#if !defined(VUINT32x8_CMPGE_DEFINED) && defined(VUINT32x4_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(u, 32, 8, 4)
+# define VUINT32x8_CMPGE_DEFINED
+#endif
+
+#if !defined(VUINT32x8_MIN_DEFINED) && defined(VUINT32x4_MIN_DEFINED)
+VEC_DOUBLE_MIN(u, 32, 8, 4)
+# define VUINT32x8_MIN_DEFINED
+#endif
+
+#if !defined(VUINT32x8_MAX_DEFINED) && defined(VUINT32x4_MAX_DEFINED)
+VEC_DOUBLE_MAX(u, 32, 8, 4)
+# define VUINT32x8_MAX_DEFINED
+#endif
+
+#if !defined(VUINT32x8_RSHIFT_DEFINED) && defined(VUINT32x4_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(u, 32, 8, 4)
+# define VUINT32x8_RSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT32x8_LRSHIFT_DEFINED) && defined(VUINT32x4_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(u, 32, 8, 4)
+# define VUINT32x8_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT32x8_LSHIFT_DEFINED) && defined(VUINT32x4_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(u, 32, 8, 4)
+# define VUINT32x8_LSHIFT_DEFINED
+#endif
+
+
+
+/* vuint32x16 */
+
+#if !defined(VINT32x16_SPLAT_DEFINED) && defined(VINT32x8_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(/* nothing */, 32, 16, 8)
+# define VINT32x16_SPLAT_DEFINED
+#endif
+
+#if !defined(VINT32x16_LOAD_ALIGNED_DEFINED) && defined(VINT32x8_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 32, 16, 8)
+# define VINT32x16_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT32x16_LOAD_DEFINED) && defined(VINT32x8_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(/* nothing */, 32, 16, 8)
+# define VINT32x16_LOAD_DEFINED
+#endif
+
+#if !defined(VINT32x16_STORE_ALIGNED_DEFINED) && defined(VINT32x8_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 32, 16, 8)
+# define VINT32x16_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT32x16_STORE_DEFINED) && defined(VINT32x8_STORE_DEFINED)
+VEC_DOUBLE_STORE(/* nothing */, 32, 16, 8)
+# define VINT32x16_STORE_DEFINED
+#endif
+
+#if !defined(VINT32x16_ADD_DEFINED) && defined(VINT32x8_ADD_DEFINED)
+VEC_DOUBLE_ADD(/* nothing */, 32, 16, 8)
+# define VINT32x16_ADD_DEFINED
+#endif
+
+#if !defined(VINT32x16_SUB_DEFINED) && defined(VINT32x8_SUB_DEFINED)
+VEC_DOUBLE_SUB(/* nothing */, 32, 16, 8)
+# define VINT32x16_SUB_DEFINED
+#endif
+
+#if !defined(VINT32x16_MUL_DEFINED) && defined(VINT32x8_MUL_DEFINED)
+VEC_DOUBLE_MUL(/* nothing */, 32, 16, 8)
+# define VINT32x16_MUL_DEFINED
+#endif
+
+#if !defined(VINT32x16_DIV_DEFINED) && defined(VINT32x8_DIV_DEFINED)
+VEC_DOUBLE_DIV(/* nothing */, 32, 16, 8)
+# define VINT32x16_DIV_DEFINED
+#endif
+
+#if !defined(VINT32x16_MOD_DEFINED) && defined(VINT32x8_MOD_DEFINED)
+VEC_DOUBLE_MOD(/* nothing */, 32, 16, 8)
+# define VINT32x16_MOD_DEFINED
+#endif
+
+#if !defined(VINT32x16_AVG_DEFINED) && defined(VINT32x8_AVG_DEFINED)
+VEC_DOUBLE_AVG(/* nothing */, 32, 16, 8)
+# define VINT32x16_AVG_DEFINED
+#endif
+
+#if !defined(VINT32x16_AND_DEFINED) && defined(VINT32x8_AND_DEFINED)
+VEC_DOUBLE_AND(/* nothing */, 32, 16, 8)
+# define VINT32x16_AND_DEFINED
+#endif
+
+#if !defined(VINT32x16_OR_DEFINED) && defined(VINT32x8_OR_DEFINED)
+VEC_DOUBLE_OR(/* nothing */, 32, 16, 8)
+# define VINT32x16_OR_DEFINED
+#endif
+
+#if !defined(VINT32x16_XOR_DEFINED) && defined(VINT32x8_XOR_DEFINED)
+VEC_DOUBLE_XOR(/* nothing */, 32, 16, 8)
+# define VINT32x16_XOR_DEFINED
+#endif
+
+#if !defined(VINT32x16_NOT_DEFINED) && defined(VINT32x8_NOT_DEFINED)
+VEC_DOUBLE_NOT(/* nothing */, 32, 16, 8)
+# define VINT32x16_NOT_DEFINED
+#endif
+
+#if !defined(VINT32x16_CMPLT_DEFINED) && defined(VINT32x8_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(/* nothing */, 32, 16, 8)
+# define VINT32x16_CMPLT_DEFINED
+#endif
+
+#if !defined(VINT32x16_CMPEQ_DEFINED) && defined(VINT32x8_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(/* nothing */, 32, 16, 8)
+# define VINT32x16_CMPEQ_DEFINED
+#endif
+
+#if !defined(VINT32x16_CMPGT_DEFINED) && defined(VINT32x8_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(/* nothing */, 32, 16, 8)
+# define VINT32x16_CMPGT_DEFINED
+#endif
+
+#if !defined(VINT32x16_CMPLE_DEFINED) && defined(VINT32x8_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(/* nothing */, 32, 16, 8)
+# define VINT32x16_CMPLE_DEFINED
+#endif
+
+#if !defined(VINT32x16_CMPGE_DEFINED) && defined(VINT32x8_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(/* nothing */, 32, 16, 8)
+# define VINT32x16_CMPGE_DEFINED
+#endif
+
+#if !defined(VINT32x16_MIN_DEFINED) && defined(VINT32x8_MIN_DEFINED)
+VEC_DOUBLE_MIN(/* nothing */, 32, 16, 8)
+# define VINT32x16_MIN_DEFINED
+#endif
+
+#if !defined(VINT32x16_MAX_DEFINED) && defined(VINT32x8_MAX_DEFINED)
+VEC_DOUBLE_MAX(/* nothing */, 32, 16, 8)
+# define VINT32x16_MAX_DEFINED
+#endif
+
+#if !defined(VINT32x16_RSHIFT_DEFINED) && defined(VINT32x8_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(/* nothing */, 32, 16, 8)
+# define VINT32x16_RSHIFT_DEFINED
+#endif
+
+#if !defined(VINT32x16_LRSHIFT_DEFINED) && defined(VINT32x8_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(/* nothing */, 32, 16, 8)
+# define VINT32x16_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VINT32x16_LSHIFT_DEFINED) && defined(VINT32x8_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(/* nothing */, 32, 16, 8)
+# define VINT32x16_LSHIFT_DEFINED
+#endif
+
+
+
+/* vint32x16 */
+
+#if !defined(VUINT32x16_SPLAT_DEFINED) && defined(VUINT32x8_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(u, 32, 16, 8)
+# define VUINT32x16_SPLAT_DEFINED
+#endif
+
+#if !defined(VUINT32x16_LOAD_ALIGNED_DEFINED) && defined(VUINT32x8_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(u, 32, 16, 8)
+# define VUINT32x16_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT32x16_LOAD_DEFINED) && defined(VUINT32x8_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(u, 32, 16, 8)
+# define VUINT32x16_LOAD_DEFINED
+#endif
+
+#if !defined(VUINT32x16_STORE_ALIGNED_DEFINED) && defined(VUINT32x8_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(u, 32, 16, 8)
+# define VUINT32x16_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT32x16_STORE_DEFINED) && defined(VUINT32x8_STORE_DEFINED)
+VEC_DOUBLE_STORE(u, 32, 16, 8)
+# define VUINT32x16_STORE_DEFINED
+#endif
+
+#if !defined(VUINT32x16_ADD_DEFINED) && defined(VUINT32x8_ADD_DEFINED)
+VEC_DOUBLE_ADD(u, 32, 16, 8)
+# define VUINT32x16_ADD_DEFINED
+#endif
+
+#if !defined(VUINT32x16_SUB_DEFINED) && defined(VUINT32x8_SUB_DEFINED)
+VEC_DOUBLE_SUB(u, 32, 16, 8)
+# define VUINT32x16_SUB_DEFINED
+#endif
+
+#if !defined(VUINT32x16_MUL_DEFINED) && defined(VUINT32x8_MUL_DEFINED)
+VEC_DOUBLE_MUL(u, 32, 16, 8)
+# define VUINT32x16_MUL_DEFINED
+#endif
+
+#if !defined(VUINT32x16_DIV_DEFINED) && defined(VUINT32x8_DIV_DEFINED)
+VEC_DOUBLE_DIV(u, 32, 16, 8)
+# define VUINT32x16_DIV_DEFINED
+#endif
+
+#if !defined(VUINT32x16_MOD_DEFINED) && defined(VUINT32x8_MOD_DEFINED)
+VEC_DOUBLE_MOD(u, 32, 16, 8)
+# define VUINT32x16_MOD_DEFINED
+#endif
+
+#if !defined(VUINT32x16_AVG_DEFINED) && defined(VUINT32x8_AVG_DEFINED)
+VEC_DOUBLE_AVG(u, 32, 16, 8)
+# define VUINT32x16_AVG_DEFINED
+#endif
+
+#if !defined(VUINT32x16_AND_DEFINED) && defined(VUINT32x8_AND_DEFINED)
+VEC_DOUBLE_AND(u, 32, 16, 8)
+# define VUINT32x16_AND_DEFINED
+#endif
+
+#if !defined(VUINT32x16_OR_DEFINED) && defined(VUINT32x8_OR_DEFINED)
+VEC_DOUBLE_OR(u, 32, 16, 8)
+# define VUINT32x16_OR_DEFINED
+#endif
+
+#if !defined(VUINT32x16_XOR_DEFINED) && defined(VUINT32x8_XOR_DEFINED)
+VEC_DOUBLE_XOR(u, 32, 16, 8)
+# define VUINT32x16_XOR_DEFINED
+#endif
+
+#if !defined(VUINT32x16_NOT_DEFINED) && defined(VUINT32x8_NOT_DEFINED)
+VEC_DOUBLE_NOT(u, 32, 16, 8)
+# define VUINT32x16_NOT_DEFINED
+#endif
+
+#if !defined(VUINT32x16_CMPLT_DEFINED) && defined(VUINT32x8_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(u, 32, 16, 8)
+# define VUINT32x16_CMPLT_DEFINED
+#endif
+
+#if !defined(VUINT32x16_CMPEQ_DEFINED) && defined(VUINT32x8_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(u, 32, 16, 8)
+# define VUINT32x16_CMPEQ_DEFINED
+#endif
+
+#if !defined(VUINT32x16_CMPGT_DEFINED) && defined(VUINT32x8_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(u, 32, 16, 8)
+# define VUINT32x16_CMPGT_DEFINED
+#endif
+
+#if !defined(VUINT32x16_CMPLE_DEFINED) && defined(VUINT32x8_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(u, 32, 16, 8)
+# define VUINT32x16_CMPLE_DEFINED
+#endif
+
+#if !defined(VUINT32x16_CMPGE_DEFINED) && defined(VUINT32x8_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(u, 32, 16, 8)
+# define VUINT32x16_CMPGE_DEFINED
+#endif
+
+#if !defined(VUINT32x16_MIN_DEFINED) && defined(VUINT32x8_MIN_DEFINED)
+VEC_DOUBLE_MIN(u, 32, 16, 8)
+# define VUINT32x16_MIN_DEFINED
+#endif
+
+#if !defined(VUINT32x16_MAX_DEFINED) && defined(VUINT32x8_MAX_DEFINED)
+VEC_DOUBLE_MAX(u, 32, 16, 8)
+# define VUINT32x16_MAX_DEFINED
+#endif
+
+#if !defined(VUINT32x16_RSHIFT_DEFINED) && defined(VUINT32x8_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(u, 32, 16, 8)
+# define VUINT32x16_RSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT32x16_LRSHIFT_DEFINED) && defined(VUINT32x8_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(u, 32, 16, 8)
+# define VUINT32x16_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT32x16_LSHIFT_DEFINED) && defined(VUINT32x8_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(u, 32, 16, 8)
+# define VUINT32x16_LSHIFT_DEFINED
+#endif
+
+
+
+/* vuint64x4 */
+
+#if !defined(VINT64x4_SPLAT_DEFINED) && defined(VINT64x2_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(/* nothing */, 64, 4, 2)
+# define VINT64x4_SPLAT_DEFINED
+#endif
+
+#if !defined(VINT64x4_LOAD_ALIGNED_DEFINED) && defined(VINT64x2_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 64, 4, 2)
+# define VINT64x4_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT64x4_LOAD_DEFINED) && defined(VINT64x2_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(/* nothing */, 64, 4, 2)
+# define VINT64x4_LOAD_DEFINED
+#endif
+
+#if !defined(VINT64x4_STORE_ALIGNED_DEFINED) && defined(VINT64x2_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 64, 4, 2)
+# define VINT64x4_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT64x4_STORE_DEFINED) && defined(VINT64x2_STORE_DEFINED)
+VEC_DOUBLE_STORE(/* nothing */, 64, 4, 2)
+# define VINT64x4_STORE_DEFINED
+#endif
+
+#if !defined(VINT64x4_ADD_DEFINED) && defined(VINT64x2_ADD_DEFINED)
+VEC_DOUBLE_ADD(/* nothing */, 64, 4, 2)
+# define VINT64x4_ADD_DEFINED
+#endif
+
+#if !defined(VINT64x4_SUB_DEFINED) && defined(VINT64x2_SUB_DEFINED)
+VEC_DOUBLE_SUB(/* nothing */, 64, 4, 2)
+# define VINT64x4_SUB_DEFINED
+#endif
+
+#if !defined(VINT64x4_MUL_DEFINED) && defined(VINT64x2_MUL_DEFINED)
+VEC_DOUBLE_MUL(/* nothing */, 64, 4, 2)
+# define VINT64x4_MUL_DEFINED
+#endif
+
+#if !defined(VINT64x4_DIV_DEFINED) && defined(VINT64x2_DIV_DEFINED)
+VEC_DOUBLE_DIV(/* nothing */, 64, 4, 2)
+# define VINT64x4_DIV_DEFINED
+#endif
+
+#if !defined(VINT64x4_MOD_DEFINED) && defined(VINT64x2_MOD_DEFINED)
+VEC_DOUBLE_MOD(/* nothing */, 64, 4, 2)
+# define VINT64x4_MOD_DEFINED
+#endif
+
+#if !defined(VINT64x4_AVG_DEFINED) && defined(VINT64x2_AVG_DEFINED)
+VEC_DOUBLE_AVG(/* nothing */, 64, 4, 2)
+# define VINT64x4_AVG_DEFINED
+#endif
+
+#if !defined(VINT64x4_AND_DEFINED) && defined(VINT64x2_AND_DEFINED)
+VEC_DOUBLE_AND(/* nothing */, 64, 4, 2)
+# define VINT64x4_AND_DEFINED
+#endif
+
+#if !defined(VINT64x4_OR_DEFINED) && defined(VINT64x2_OR_DEFINED)
+VEC_DOUBLE_OR(/* nothing */, 64, 4, 2)
+# define VINT64x4_OR_DEFINED
+#endif
+
+#if !defined(VINT64x4_XOR_DEFINED) && defined(VINT64x2_XOR_DEFINED)
+VEC_DOUBLE_XOR(/* nothing */, 64, 4, 2)
+# define VINT64x4_XOR_DEFINED
+#endif
+
+#if !defined(VINT64x4_NOT_DEFINED) && defined(VINT64x2_NOT_DEFINED)
+VEC_DOUBLE_NOT(/* nothing */, 64, 4, 2)
+# define VINT64x4_NOT_DEFINED
+#endif
+
+#if !defined(VINT64x4_CMPLT_DEFINED) && defined(VINT64x2_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(/* nothing */, 64, 4, 2)
+# define VINT64x4_CMPLT_DEFINED
+#endif
+
+#if !defined(VINT64x4_CMPEQ_DEFINED) && defined(VINT64x2_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(/* nothing */, 64, 4, 2)
+# define VINT64x4_CMPEQ_DEFINED
+#endif
+
+#if !defined(VINT64x4_CMPGT_DEFINED) && defined(VINT64x2_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(/* nothing */, 64, 4, 2)
+# define VINT64x4_CMPGT_DEFINED
+#endif
+
+#if !defined(VINT64x4_CMPLE_DEFINED) && defined(VINT64x2_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(/* nothing */, 64, 4, 2)
+# define VINT64x4_CMPLE_DEFINED
+#endif
+
+#if !defined(VINT64x4_CMPGE_DEFINED) && defined(VINT64x2_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(/* nothing */, 64, 4, 2)
+# define VINT64x4_CMPGE_DEFINED
+#endif
+
+#if !defined(VINT64x4_MIN_DEFINED) && defined(VINT64x2_MIN_DEFINED)
+VEC_DOUBLE_MIN(/* nothing */, 64, 4, 2)
+# define VINT64x4_MIN_DEFINED
+#endif
+
+#if !defined(VINT64x4_MAX_DEFINED) && defined(VINT64x2_MAX_DEFINED)
+VEC_DOUBLE_MAX(/* nothing */, 64, 4, 2)
+# define VINT64x4_MAX_DEFINED
+#endif
+
+#if !defined(VINT64x4_RSHIFT_DEFINED) && defined(VINT64x2_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(/* nothing */, 64, 4, 2)
+# define VINT64x4_RSHIFT_DEFINED
+#endif
+
+#if !defined(VINT64x4_LRSHIFT_DEFINED) && defined(VINT64x2_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(/* nothing */, 64, 4, 2)
+# define VINT64x4_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VINT64x4_LSHIFT_DEFINED) && defined(VINT64x2_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(/* nothing */, 64, 4, 2)
+# define VINT64x4_LSHIFT_DEFINED
+#endif
+
+
+
+/* vint64x4 */
+
+#if !defined(VUINT64x4_SPLAT_DEFINED) && defined(VUINT64x2_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(u, 64, 4, 2)
+# define VUINT64x4_SPLAT_DEFINED
+#endif
+
+#if !defined(VUINT64x4_LOAD_ALIGNED_DEFINED) && defined(VUINT64x2_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(u, 64, 4, 2)
+# define VUINT64x4_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT64x4_LOAD_DEFINED) && defined(VUINT64x2_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(u, 64, 4, 2)
+# define VUINT64x4_LOAD_DEFINED
+#endif
+
+#if !defined(VUINT64x4_STORE_ALIGNED_DEFINED) && defined(VUINT64x2_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(u, 64, 4, 2)
+# define VUINT64x4_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT64x4_STORE_DEFINED) && defined(VUINT64x2_STORE_DEFINED)
+VEC_DOUBLE_STORE(u, 64, 4, 2)
+# define VUINT64x4_STORE_DEFINED
+#endif
+
+#if !defined(VUINT64x4_ADD_DEFINED) && defined(VUINT64x2_ADD_DEFINED)
+VEC_DOUBLE_ADD(u, 64, 4, 2)
+# define VUINT64x4_ADD_DEFINED
+#endif
+
+#if !defined(VUINT64x4_SUB_DEFINED) && defined(VUINT64x2_SUB_DEFINED)
+VEC_DOUBLE_SUB(u, 64, 4, 2)
+# define VUINT64x4_SUB_DEFINED
+#endif
+
+#if !defined(VUINT64x4_MUL_DEFINED) && defined(VUINT64x2_MUL_DEFINED)
+VEC_DOUBLE_MUL(u, 64, 4, 2)
+# define VUINT64x4_MUL_DEFINED
+#endif
+
+#if !defined(VUINT64x4_DIV_DEFINED) && defined(VUINT64x2_DIV_DEFINED)
+VEC_DOUBLE_DIV(u, 64, 4, 2)
+# define VUINT64x4_DIV_DEFINED
+#endif
+
+#if !defined(VUINT64x4_MOD_DEFINED) && defined(VUINT64x2_MOD_DEFINED)
+VEC_DOUBLE_MOD(u, 64, 4, 2)
+# define VUINT64x4_MOD_DEFINED
+#endif
+
+#if !defined(VUINT64x4_AVG_DEFINED) && defined(VUINT64x2_AVG_DEFINED)
+VEC_DOUBLE_AVG(u, 64, 4, 2)
+# define VUINT64x4_AVG_DEFINED
+#endif
+
+#if !defined(VUINT64x4_AND_DEFINED) && defined(VUINT64x2_AND_DEFINED)
+VEC_DOUBLE_AND(u, 64, 4, 2)
+# define VUINT64x4_AND_DEFINED
+#endif
+
+#if !defined(VUINT64x4_OR_DEFINED) && defined(VUINT64x2_OR_DEFINED)
+VEC_DOUBLE_OR(u, 64, 4, 2)
+# define VUINT64x4_OR_DEFINED
+#endif
+
+#if !defined(VUINT64x4_XOR_DEFINED) && defined(VUINT64x2_XOR_DEFINED)
+VEC_DOUBLE_XOR(u, 64, 4, 2)
+# define VUINT64x4_XOR_DEFINED
+#endif
+
+#if !defined(VUINT64x4_NOT_DEFINED) && defined(VUINT64x2_NOT_DEFINED)
+VEC_DOUBLE_NOT(u, 64, 4, 2)
+# define VUINT64x4_NOT_DEFINED
+#endif
+
+#if !defined(VUINT64x4_CMPLT_DEFINED) && defined(VUINT64x2_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(u, 64, 4, 2)
+# define VUINT64x4_CMPLT_DEFINED
+#endif
+
+#if !defined(VUINT64x4_CMPEQ_DEFINED) && defined(VUINT64x2_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(u, 64, 4, 2)
+# define VUINT64x4_CMPEQ_DEFINED
+#endif
+
+#if !defined(VUINT64x4_CMPGT_DEFINED) && defined(VUINT64x2_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(u, 64, 4, 2)
+# define VUINT64x4_CMPGT_DEFINED
+#endif
+
+#if !defined(VUINT64x4_CMPLE_DEFINED) && defined(VUINT64x2_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(u, 64, 4, 2)
+# define VUINT64x4_CMPLE_DEFINED
+#endif
+
+#if !defined(VUINT64x4_CMPGE_DEFINED) && defined(VUINT64x2_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(u, 64, 4, 2)
+# define VUINT64x4_CMPGE_DEFINED
+#endif
+
+#if !defined(VUINT64x4_MIN_DEFINED) && defined(VUINT64x2_MIN_DEFINED)
+VEC_DOUBLE_MIN(u, 64, 4, 2)
+# define VUINT64x4_MIN_DEFINED
+#endif
+
+#if !defined(VUINT64x4_MAX_DEFINED) && defined(VUINT64x2_MAX_DEFINED)
+VEC_DOUBLE_MAX(u, 64, 4, 2)
+# define VUINT64x4_MAX_DEFINED
+#endif
+
+#if !defined(VUINT64x4_RSHIFT_DEFINED) && defined(VUINT64x2_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(u, 64, 4, 2)
+# define VUINT64x4_RSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT64x4_LRSHIFT_DEFINED) && defined(VUINT64x2_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(u, 64, 4, 2)
+# define VUINT64x4_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT64x4_LSHIFT_DEFINED) && defined(VUINT64x2_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(u, 64, 4, 2)
+# define VUINT64x4_LSHIFT_DEFINED
+#endif
+
+
+
+/* vuint64x8 */
+
+#if !defined(VINT64x8_SPLAT_DEFINED) && defined(VINT64x4_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(/* nothing */, 64, 8, 4)
+# define VINT64x8_SPLAT_DEFINED
+#endif
+
+#if !defined(VINT64x8_LOAD_ALIGNED_DEFINED) && defined(VINT64x4_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(/* nothing */, 64, 8, 4)
+# define VINT64x8_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT64x8_LOAD_DEFINED) && defined(VINT64x4_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(/* nothing */, 64, 8, 4)
+# define VINT64x8_LOAD_DEFINED
+#endif
+
+#if !defined(VINT64x8_STORE_ALIGNED_DEFINED) && defined(VINT64x4_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(/* nothing */, 64, 8, 4)
+# define VINT64x8_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VINT64x8_STORE_DEFINED) && defined(VINT64x4_STORE_DEFINED)
+VEC_DOUBLE_STORE(/* nothing */, 64, 8, 4)
+# define VINT64x8_STORE_DEFINED
+#endif
+
+#if !defined(VINT64x8_ADD_DEFINED) && defined(VINT64x4_ADD_DEFINED)
+VEC_DOUBLE_ADD(/* nothing */, 64, 8, 4)
+# define VINT64x8_ADD_DEFINED
+#endif
+
+#if !defined(VINT64x8_SUB_DEFINED) && defined(VINT64x4_SUB_DEFINED)
+VEC_DOUBLE_SUB(/* nothing */, 64, 8, 4)
+# define VINT64x8_SUB_DEFINED
+#endif
+
+#if !defined(VINT64x8_MUL_DEFINED) && defined(VINT64x4_MUL_DEFINED)
+VEC_DOUBLE_MUL(/* nothing */, 64, 8, 4)
+# define VINT64x8_MUL_DEFINED
+#endif
+
+#if !defined(VINT64x8_DIV_DEFINED) && defined(VINT64x4_DIV_DEFINED)
+VEC_DOUBLE_DIV(/* nothing */, 64, 8, 4)
+# define VINT64x8_DIV_DEFINED
+#endif
+
+#if !defined(VINT64x8_MOD_DEFINED) && defined(VINT64x4_MOD_DEFINED)
+VEC_DOUBLE_MOD(/* nothing */, 64, 8, 4)
+# define VINT64x8_MOD_DEFINED
+#endif
+
+#if !defined(VINT64x8_AVG_DEFINED) && defined(VINT64x4_AVG_DEFINED)
+VEC_DOUBLE_AVG(/* nothing */, 64, 8, 4)
+# define VINT64x8_AVG_DEFINED
+#endif
+
+#if !defined(VINT64x8_AND_DEFINED) && defined(VINT64x4_AND_DEFINED)
+VEC_DOUBLE_AND(/* nothing */, 64, 8, 4)
+# define VINT64x8_AND_DEFINED
+#endif
+
+#if !defined(VINT64x8_OR_DEFINED) && defined(VINT64x4_OR_DEFINED)
+VEC_DOUBLE_OR(/* nothing */, 64, 8, 4)
+# define VINT64x8_OR_DEFINED
+#endif
+
+#if !defined(VINT64x8_XOR_DEFINED) && defined(VINT64x4_XOR_DEFINED)
+VEC_DOUBLE_XOR(/* nothing */, 64, 8, 4)
+# define VINT64x8_XOR_DEFINED
+#endif
+
+#if !defined(VINT64x8_NOT_DEFINED) && defined(VINT64x4_NOT_DEFINED)
+VEC_DOUBLE_NOT(/* nothing */, 64, 8, 4)
+# define VINT64x8_NOT_DEFINED
+#endif
+
+#if !defined(VINT64x8_CMPLT_DEFINED) && defined(VINT64x4_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(/* nothing */, 64, 8, 4)
+# define VINT64x8_CMPLT_DEFINED
+#endif
+
+#if !defined(VINT64x8_CMPEQ_DEFINED) && defined(VINT64x4_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(/* nothing */, 64, 8, 4)
+# define VINT64x8_CMPEQ_DEFINED
+#endif
+
+#if !defined(VINT64x8_CMPGT_DEFINED) && defined(VINT64x4_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(/* nothing */, 64, 8, 4)
+# define VINT64x8_CMPGT_DEFINED
+#endif
+
+#if !defined(VINT64x8_CMPLE_DEFINED) && defined(VINT64x4_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(/* nothing */, 64, 8, 4)
+# define VINT64x8_CMPLE_DEFINED
+#endif
+
+#if !defined(VINT64x8_CMPGE_DEFINED) && defined(VINT64x4_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(/* nothing */, 64, 8, 4)
+# define VINT64x8_CMPGE_DEFINED
+#endif
+
+#if !defined(VINT64x8_MIN_DEFINED) && defined(VINT64x4_MIN_DEFINED)
+VEC_DOUBLE_MIN(/* nothing */, 64, 8, 4)
+# define VINT64x8_MIN_DEFINED
+#endif
+
+#if !defined(VINT64x8_MAX_DEFINED) && defined(VINT64x4_MAX_DEFINED)
+VEC_DOUBLE_MAX(/* nothing */, 64, 8, 4)
+# define VINT64x8_MAX_DEFINED
+#endif
+
+#if !defined(VINT64x8_RSHIFT_DEFINED) && defined(VINT64x4_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(/* nothing */, 64, 8, 4)
+# define VINT64x8_RSHIFT_DEFINED
+#endif
+
+#if !defined(VINT64x8_LRSHIFT_DEFINED) && defined(VINT64x4_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(/* nothing */, 64, 8, 4)
+# define VINT64x8_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VINT64x8_LSHIFT_DEFINED) && defined(VINT64x4_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(/* nothing */, 64, 8, 4)
+# define VINT64x8_LSHIFT_DEFINED
+#endif
+
+
+
+/* vint64x8 */
+
+#if !defined(VUINT64x8_SPLAT_DEFINED) && defined(VUINT64x4_SPLAT_DEFINED)
+VEC_DOUBLE_SPLAT(u, 64, 8, 4)
+# define VUINT64x8_SPLAT_DEFINED
+#endif
+
+#if !defined(VUINT64x8_LOAD_ALIGNED_DEFINED) && defined(VUINT64x4_LOAD_ALIGNED_DEFINED)
+VEC_DOUBLE_LOAD_ALIGNED(u, 64, 8, 4)
+# define VUINT64x8_LOAD_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT64x8_LOAD_DEFINED) && defined(VUINT64x4_LOAD_DEFINED)
+VEC_DOUBLE_LOAD(u, 64, 8, 4)
+# define VUINT64x8_LOAD_DEFINED
+#endif
+
+#if !defined(VUINT64x8_STORE_ALIGNED_DEFINED) && defined(VUINT64x4_STORE_ALIGNED_DEFINED)
+VEC_DOUBLE_STORE_ALIGNED(u, 64, 8, 4)
+# define VUINT64x8_STORE_ALIGNED_DEFINED
+#endif
+
+#if !defined(VUINT64x8_STORE_DEFINED) && defined(VUINT64x4_STORE_DEFINED)
+VEC_DOUBLE_STORE(u, 64, 8, 4)
+# define VUINT64x8_STORE_DEFINED
+#endif
+
+#if !defined(VUINT64x8_ADD_DEFINED) && defined(VUINT64x4_ADD_DEFINED)
+VEC_DOUBLE_ADD(u, 64, 8, 4)
+# define VUINT64x8_ADD_DEFINED
+#endif
+
+#if !defined(VUINT64x8_SUB_DEFINED) && defined(VUINT64x4_SUB_DEFINED)
+VEC_DOUBLE_SUB(u, 64, 8, 4)
+# define VUINT64x8_SUB_DEFINED
+#endif
+
+#if !defined(VUINT64x8_MUL_DEFINED) && defined(VUINT64x4_MUL_DEFINED)
+VEC_DOUBLE_MUL(u, 64, 8, 4)
+# define VUINT64x8_MUL_DEFINED
+#endif
+
+#if !defined(VUINT64x8_DIV_DEFINED) && defined(VUINT64x4_DIV_DEFINED)
+VEC_DOUBLE_DIV(u, 64, 8, 4)
+# define VUINT64x8_DIV_DEFINED
+#endif
+
+#if !defined(VUINT64x8_MOD_DEFINED) && defined(VUINT64x4_MOD_DEFINED)
+VEC_DOUBLE_MOD(u, 64, 8, 4)
+# define VUINT64x8_MOD_DEFINED
+#endif
+
+#if !defined(VUINT64x8_AVG_DEFINED) && defined(VUINT64x4_AVG_DEFINED)
+VEC_DOUBLE_AVG(u, 64, 8, 4)
+# define VUINT64x8_AVG_DEFINED
+#endif
+
+#if !defined(VUINT64x8_AND_DEFINED) && defined(VUINT64x4_AND_DEFINED)
+VEC_DOUBLE_AND(u, 64, 8, 4)
+# define VUINT64x8_AND_DEFINED
+#endif
+
+#if !defined(VUINT64x8_OR_DEFINED) && defined(VUINT64x4_OR_DEFINED)
+VEC_DOUBLE_OR(u, 64, 8, 4)
+# define VUINT64x8_OR_DEFINED
+#endif
+
+#if !defined(VUINT64x8_XOR_DEFINED) && defined(VUINT64x4_XOR_DEFINED)
+VEC_DOUBLE_XOR(u, 64, 8, 4)
+# define VUINT64x8_XOR_DEFINED
+#endif
+
+#if !defined(VUINT64x8_NOT_DEFINED) && defined(VUINT64x4_NOT_DEFINED)
+VEC_DOUBLE_NOT(u, 64, 8, 4)
+# define VUINT64x8_NOT_DEFINED
+#endif
+
+#if !defined(VUINT64x8_CMPLT_DEFINED) && defined(VUINT64x4_CMPLT_DEFINED)
+VEC_DOUBLE_CMPLT(u, 64, 8, 4)
+# define VUINT64x8_CMPLT_DEFINED
+#endif
+
+#if !defined(VUINT64x8_CMPEQ_DEFINED) && defined(VUINT64x4_CMPEQ_DEFINED)
+VEC_DOUBLE_CMPEQ(u, 64, 8, 4)
+# define VUINT64x8_CMPEQ_DEFINED
+#endif
+
+#if !defined(VUINT64x8_CMPGT_DEFINED) && defined(VUINT64x4_CMPGT_DEFINED)
+VEC_DOUBLE_CMPGT(u, 64, 8, 4)
+# define VUINT64x8_CMPGT_DEFINED
+#endif
+
+#if !defined(VUINT64x8_CMPLE_DEFINED) && defined(VUINT64x4_CMPLE_DEFINED)
+VEC_DOUBLE_CMPLE(u, 64, 8, 4)
+# define VUINT64x8_CMPLE_DEFINED
+#endif
+
+#if !defined(VUINT64x8_CMPGE_DEFINED) && defined(VUINT64x4_CMPGE_DEFINED)
+VEC_DOUBLE_CMPGE(u, 64, 8, 4)
+# define VUINT64x8_CMPGE_DEFINED
+#endif
+
+#if !defined(VUINT64x8_MIN_DEFINED) && defined(VUINT64x4_MIN_DEFINED)
+VEC_DOUBLE_MIN(u, 64, 8, 4)
+# define VUINT64x8_MIN_DEFINED
+#endif
+
+#if !defined(VUINT64x8_MAX_DEFINED) && defined(VUINT64x4_MAX_DEFINED)
+VEC_DOUBLE_MAX(u, 64, 8, 4)
+# define VUINT64x8_MAX_DEFINED
+#endif
+
+#if !defined(VUINT64x8_RSHIFT_DEFINED) && defined(VUINT64x4_RSHIFT_DEFINED)
+VEC_DOUBLE_RSHIFT(u, 64, 8, 4)
+# define VUINT64x8_RSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT64x8_LRSHIFT_DEFINED) && defined(VUINT64x4_LRSHIFT_DEFINED)
+VEC_DOUBLE_LRSHIFT(u, 64, 8, 4)
+# define VUINT64x8_LRSHIFT_DEFINED
+#endif
+
+#if !defined(VUINT64x8_LSHIFT_DEFINED) && defined(VUINT64x4_LSHIFT_DEFINED)
+VEC_DOUBLE_LSHIFT(u, 64, 8, 4)
+# define VUINT64x8_LSHIFT_DEFINED
+#endif
+
+
diff -r 55cadb1fac4b -r c6e0df09b86f include/vec/impl/gcc.h
--- a/include/vec/impl/gcc.h	Sun Apr 27 02:49:53 2025 -0400
+++ b/include/vec/impl/gcc.h	Mon Apr 28 16:31:59 2025 -0400
@@ -122,6 +122,7 @@
 }
 # define VINT8x2_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x2_CMPLT_DEFINED
 VEC_FUNC_IMPL vint8x2 vint8x2_cmplt(vint8x2 vec1, vint8x2 vec2)
 {
@@ -130,6 +131,8 @@
 }
 # define VINT8x2_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x2_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint8x2 vint8x2_cmpeq(vint8x2 vec1, vint8x2 vec2)
 {
@@ -138,6 +141,8 @@
 }
 # define VINT8x2_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x2_CMPGT_DEFINED
 VEC_FUNC_IMPL vint8x2 vint8x2_cmpgt(vint8x2 vec1, vint8x2 vec2)
 {
@@ -146,6 +151,8 @@
 }
 # define VINT8x2_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x2_CMPLE_DEFINED
 VEC_FUNC_IMPL vint8x2 vint8x2_cmple(vint8x2 vec1, vint8x2 vec2)
 {
@@ -154,6 +161,8 @@
 }
 # define VINT8x2_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x2_CMPGE_DEFINED
 VEC_FUNC_IMPL vint8x2 vint8x2_cmpge(vint8x2 vec1, vint8x2 vec2)
 {
@@ -162,6 +171,8 @@
 }
 # define VINT8x2_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x2_MIN_DEFINED
 VEC_FUNC_IMPL vint8x2 vint8x2_min(vint8x2 vec1, vint8x2 vec2)
 {
@@ -172,6 +183,8 @@
 }
 # define VINT8x2_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x2_MAX_DEFINED
 VEC_FUNC_IMPL vint8x2 vint8x2_max(vint8x2 vec1, vint8x2 vec2)
 {
@@ -182,6 +195,8 @@
 }
 # define VINT8x2_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x2_AVG_DEFINED
 VEC_FUNC_IMPL vint8x2 vint8x2_avg(vint8x2 vec1, vint8x2 vec2)
 {
@@ -196,6 +211,8 @@
 }
 # define VINT8x2_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x2_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x2 vint8x2_lshift(vint8x2 vec1, vuint8x2 vec2)
 {
@@ -204,6 +221,8 @@
 }
 # define VINT8x2_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x2_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x2 vint8x2_rshift(vint8x2 vec1, vuint8x2 vec2)
 {
@@ -212,6 +231,8 @@
 }
 # define VINT8x2_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x2_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x2 vint8x2_lrshift(vint8x2 vec1, vuint8x2 vec2)
 {
@@ -220,6 +241,7 @@
 }
 # define VINT8x2_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT8x2_NOT_DEFINED
 VEC_FUNC_IMPL vint8x2 vint8x2_not(vint8x2 vec)
 {
@@ -321,6 +343,7 @@
 }
 # define VUINT8x2_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x2_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint8x2 vuint8x2_cmplt(vuint8x2 vec1, vuint8x2 vec2)
 {
@@ -329,6 +352,8 @@
 }
 # define VUINT8x2_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x2_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint8x2 vuint8x2_cmpeq(vuint8x2 vec1, vuint8x2 vec2)
 {
@@ -337,6 +362,8 @@
 }
 # define VUINT8x2_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x2_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint8x2 vuint8x2_cmpgt(vuint8x2 vec1, vuint8x2 vec2)
 {
@@ -345,6 +372,8 @@
 }
 # define VUINT8x2_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x2_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint8x2 vuint8x2_cmple(vuint8x2 vec1, vuint8x2 vec2)
 {
@@ -353,6 +382,8 @@
 }
 # define VUINT8x2_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x2_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint8x2 vuint8x2_cmpge(vuint8x2 vec1, vuint8x2 vec2)
 {
@@ -361,6 +392,8 @@
 }
 # define VUINT8x2_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x2_MIN_DEFINED
 VEC_FUNC_IMPL vuint8x2 vuint8x2_min(vuint8x2 vec1, vuint8x2 vec2)
 {
@@ -371,6 +404,8 @@
 }
 # define VUINT8x2_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x2_MAX_DEFINED
 VEC_FUNC_IMPL vuint8x2 vuint8x2_max(vuint8x2 vec1, vuint8x2 vec2)
 {
@@ -381,14 +416,19 @@
 }
 # define VUINT8x2_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x2_AVG_DEFINED
 VEC_FUNC_IMPL vuint8x2 vuint8x2_avg(vuint8x2 vec1, vuint8x2 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint8x2 ones = vint8x2_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT8x2_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x2_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x2 vuint8x2_lshift(vuint8x2 vec1, vuint8x2 vec2)
 {
@@ -397,6 +437,8 @@
 }
 # define VUINT8x2_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x2_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x2 vuint8x2_rshift(vuint8x2 vec1, vuint8x2 vec2)
 {
@@ -405,6 +447,8 @@
 }
 # define VUINT8x2_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x2_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x2 vuint8x2_lrshift(vuint8x2 vec1, vuint8x2 vec2)
 {
@@ -413,6 +457,7 @@
 }
 # define VUINT8x2_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT8x2_NOT_DEFINED
 VEC_FUNC_IMPL vuint8x2 vuint8x2_not(vuint8x2 vec)
 {
@@ -514,6 +559,7 @@
 }
 # define VINT8x4_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x4_CMPLT_DEFINED
 VEC_FUNC_IMPL vint8x4 vint8x4_cmplt(vint8x4 vec1, vint8x4 vec2)
 {
@@ -522,6 +568,8 @@
 }
 # define VINT8x4_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x4_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint8x4 vint8x4_cmpeq(vint8x4 vec1, vint8x4 vec2)
 {
@@ -530,6 +578,8 @@
 }
 # define VINT8x4_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x4_CMPGT_DEFINED
 VEC_FUNC_IMPL vint8x4 vint8x4_cmpgt(vint8x4 vec1, vint8x4 vec2)
 {
@@ -538,6 +588,8 @@
 }
 # define VINT8x4_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x4_CMPLE_DEFINED
 VEC_FUNC_IMPL vint8x4 vint8x4_cmple(vint8x4 vec1, vint8x4 vec2)
 {
@@ -546,6 +598,8 @@
 }
 # define VINT8x4_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x4_CMPGE_DEFINED
 VEC_FUNC_IMPL vint8x4 vint8x4_cmpge(vint8x4 vec1, vint8x4 vec2)
 {
@@ -554,6 +608,8 @@
 }
 # define VINT8x4_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x4_MIN_DEFINED
 VEC_FUNC_IMPL vint8x4 vint8x4_min(vint8x4 vec1, vint8x4 vec2)
 {
@@ -564,6 +620,8 @@
 }
 # define VINT8x4_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x4_MAX_DEFINED
 VEC_FUNC_IMPL vint8x4 vint8x4_max(vint8x4 vec1, vint8x4 vec2)
 {
@@ -574,6 +632,8 @@
 }
 # define VINT8x4_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x4_AVG_DEFINED
 VEC_FUNC_IMPL vint8x4 vint8x4_avg(vint8x4 vec1, vint8x4 vec2)
 {
@@ -588,6 +648,8 @@
 }
 # define VINT8x4_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x4_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x4 vint8x4_lshift(vint8x4 vec1, vuint8x4 vec2)
 {
@@ -596,6 +658,8 @@
 }
 # define VINT8x4_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x4_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x4 vint8x4_rshift(vint8x4 vec1, vuint8x4 vec2)
 {
@@ -604,6 +668,8 @@
 }
 # define VINT8x4_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x4_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x4 vint8x4_lrshift(vint8x4 vec1, vuint8x4 vec2)
 {
@@ -612,6 +678,7 @@
 }
 # define VINT8x4_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT8x4_NOT_DEFINED
 VEC_FUNC_IMPL vint8x4 vint8x4_not(vint8x4 vec)
 {
@@ -713,6 +780,7 @@
 }
 # define VUINT8x4_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x4_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint8x4 vuint8x4_cmplt(vuint8x4 vec1, vuint8x4 vec2)
 {
@@ -721,6 +789,8 @@
 }
 # define VUINT8x4_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x4_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint8x4 vuint8x4_cmpeq(vuint8x4 vec1, vuint8x4 vec2)
 {
@@ -729,6 +799,8 @@
 }
 # define VUINT8x4_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x4_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint8x4 vuint8x4_cmpgt(vuint8x4 vec1, vuint8x4 vec2)
 {
@@ -737,6 +809,8 @@
 }
 # define VUINT8x4_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x4_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint8x4 vuint8x4_cmple(vuint8x4 vec1, vuint8x4 vec2)
 {
@@ -745,6 +819,8 @@
 }
 # define VUINT8x4_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x4_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint8x4 vuint8x4_cmpge(vuint8x4 vec1, vuint8x4 vec2)
 {
@@ -753,6 +829,8 @@
 }
 # define VUINT8x4_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x4_MIN_DEFINED
 VEC_FUNC_IMPL vuint8x4 vuint8x4_min(vuint8x4 vec1, vuint8x4 vec2)
 {
@@ -763,6 +841,8 @@
 }
 # define VUINT8x4_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x4_MAX_DEFINED
 VEC_FUNC_IMPL vuint8x4 vuint8x4_max(vuint8x4 vec1, vuint8x4 vec2)
 {
@@ -773,14 +853,19 @@
 }
 # define VUINT8x4_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x4_AVG_DEFINED
 VEC_FUNC_IMPL vuint8x4 vuint8x4_avg(vuint8x4 vec1, vuint8x4 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint8x4 ones = vint8x4_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT8x4_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x4_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x4 vuint8x4_lshift(vuint8x4 vec1, vuint8x4 vec2)
 {
@@ -789,6 +874,8 @@
 }
 # define VUINT8x4_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x4_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x4 vuint8x4_rshift(vuint8x4 vec1, vuint8x4 vec2)
 {
@@ -797,6 +884,8 @@
 }
 # define VUINT8x4_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x4_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x4 vuint8x4_lrshift(vuint8x4 vec1, vuint8x4 vec2)
 {
@@ -805,6 +894,7 @@
 }
 # define VUINT8x4_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT8x4_NOT_DEFINED
 VEC_FUNC_IMPL vuint8x4 vuint8x4_not(vuint8x4 vec)
 {
@@ -906,6 +996,7 @@
 }
 # define VINT8x8_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x8_CMPLT_DEFINED
 VEC_FUNC_IMPL vint8x8 vint8x8_cmplt(vint8x8 vec1, vint8x8 vec2)
 {
@@ -914,6 +1005,8 @@
 }
 # define VINT8x8_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x8_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint8x8 vint8x8_cmpeq(vint8x8 vec1, vint8x8 vec2)
 {
@@ -922,6 +1015,8 @@
 }
 # define VINT8x8_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x8_CMPGT_DEFINED
 VEC_FUNC_IMPL vint8x8 vint8x8_cmpgt(vint8x8 vec1, vint8x8 vec2)
 {
@@ -930,6 +1025,8 @@
 }
 # define VINT8x8_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x8_CMPLE_DEFINED
 VEC_FUNC_IMPL vint8x8 vint8x8_cmple(vint8x8 vec1, vint8x8 vec2)
 {
@@ -938,6 +1035,8 @@
 }
 # define VINT8x8_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x8_CMPGE_DEFINED
 VEC_FUNC_IMPL vint8x8 vint8x8_cmpge(vint8x8 vec1, vint8x8 vec2)
 {
@@ -946,6 +1045,8 @@
 }
 # define VINT8x8_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x8_MIN_DEFINED
 VEC_FUNC_IMPL vint8x8 vint8x8_min(vint8x8 vec1, vint8x8 vec2)
 {
@@ -956,6 +1057,8 @@
 }
 # define VINT8x8_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x8_MAX_DEFINED
 VEC_FUNC_IMPL vint8x8 vint8x8_max(vint8x8 vec1, vint8x8 vec2)
 {
@@ -966,6 +1069,8 @@
 }
 # define VINT8x8_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x8_AVG_DEFINED
 VEC_FUNC_IMPL vint8x8 vint8x8_avg(vint8x8 vec1, vint8x8 vec2)
 {
@@ -980,6 +1085,8 @@
 }
 # define VINT8x8_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x8_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x8 vint8x8_lshift(vint8x8 vec1, vuint8x8 vec2)
 {
@@ -988,6 +1095,8 @@
 }
 # define VINT8x8_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x8_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x8 vint8x8_rshift(vint8x8 vec1, vuint8x8 vec2)
 {
@@ -996,6 +1105,8 @@
 }
 # define VINT8x8_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x8_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x8 vint8x8_lrshift(vint8x8 vec1, vuint8x8 vec2)
 {
@@ -1004,6 +1115,7 @@
 }
 # define VINT8x8_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT8x8_NOT_DEFINED
 VEC_FUNC_IMPL vint8x8 vint8x8_not(vint8x8 vec)
 {
@@ -1105,6 +1217,7 @@
 }
 # define VUINT8x8_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x8_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint8x8 vuint8x8_cmplt(vuint8x8 vec1, vuint8x8 vec2)
 {
@@ -1113,6 +1226,8 @@
 }
 # define VUINT8x8_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x8_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint8x8 vuint8x8_cmpeq(vuint8x8 vec1, vuint8x8 vec2)
 {
@@ -1121,6 +1236,8 @@
 }
 # define VUINT8x8_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x8_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint8x8 vuint8x8_cmpgt(vuint8x8 vec1, vuint8x8 vec2)
 {
@@ -1129,6 +1246,8 @@
 }
 # define VUINT8x8_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x8_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint8x8 vuint8x8_cmple(vuint8x8 vec1, vuint8x8 vec2)
 {
@@ -1137,6 +1256,8 @@
 }
 # define VUINT8x8_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x8_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint8x8 vuint8x8_cmpge(vuint8x8 vec1, vuint8x8 vec2)
 {
@@ -1145,6 +1266,8 @@
 }
 # define VUINT8x8_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x8_MIN_DEFINED
 VEC_FUNC_IMPL vuint8x8 vuint8x8_min(vuint8x8 vec1, vuint8x8 vec2)
 {
@@ -1155,6 +1278,8 @@
 }
 # define VUINT8x8_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x8_MAX_DEFINED
 VEC_FUNC_IMPL vuint8x8 vuint8x8_max(vuint8x8 vec1, vuint8x8 vec2)
 {
@@ -1165,14 +1290,19 @@
 }
 # define VUINT8x8_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x8_AVG_DEFINED
 VEC_FUNC_IMPL vuint8x8 vuint8x8_avg(vuint8x8 vec1, vuint8x8 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint8x8 ones = vint8x8_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT8x8_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x8_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x8 vuint8x8_lshift(vuint8x8 vec1, vuint8x8 vec2)
 {
@@ -1181,6 +1311,8 @@
 }
 # define VUINT8x8_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x8_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x8 vuint8x8_rshift(vuint8x8 vec1, vuint8x8 vec2)
 {
@@ -1189,6 +1321,8 @@
 }
 # define VUINT8x8_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x8_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x8 vuint8x8_lrshift(vuint8x8 vec1, vuint8x8 vec2)
 {
@@ -1197,6 +1331,7 @@
 }
 # define VUINT8x8_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT8x8_NOT_DEFINED
 VEC_FUNC_IMPL vuint8x8 vuint8x8_not(vuint8x8 vec)
 {
@@ -1298,6 +1433,7 @@
 }
 # define VINT8x16_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x16_CMPLT_DEFINED
 VEC_FUNC_IMPL vint8x16 vint8x16_cmplt(vint8x16 vec1, vint8x16 vec2)
 {
@@ -1306,6 +1442,8 @@
 }
 # define VINT8x16_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x16_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint8x16 vint8x16_cmpeq(vint8x16 vec1, vint8x16 vec2)
 {
@@ -1314,6 +1452,8 @@
 }
 # define VINT8x16_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x16_CMPGT_DEFINED
 VEC_FUNC_IMPL vint8x16 vint8x16_cmpgt(vint8x16 vec1, vint8x16 vec2)
 {
@@ -1322,6 +1462,8 @@
 }
 # define VINT8x16_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x16_CMPLE_DEFINED
 VEC_FUNC_IMPL vint8x16 vint8x16_cmple(vint8x16 vec1, vint8x16 vec2)
 {
@@ -1330,6 +1472,8 @@
 }
 # define VINT8x16_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x16_CMPGE_DEFINED
 VEC_FUNC_IMPL vint8x16 vint8x16_cmpge(vint8x16 vec1, vint8x16 vec2)
 {
@@ -1338,6 +1482,8 @@
 }
 # define VINT8x16_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x16_MIN_DEFINED
 VEC_FUNC_IMPL vint8x16 vint8x16_min(vint8x16 vec1, vint8x16 vec2)
 {
@@ -1348,6 +1494,8 @@
 }
 # define VINT8x16_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x16_MAX_DEFINED
 VEC_FUNC_IMPL vint8x16 vint8x16_max(vint8x16 vec1, vint8x16 vec2)
 {
@@ -1358,6 +1506,8 @@
 }
 # define VINT8x16_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x16_AVG_DEFINED
 VEC_FUNC_IMPL vint8x16 vint8x16_avg(vint8x16 vec1, vint8x16 vec2)
 {
@@ -1372,6 +1522,8 @@
 }
 # define VINT8x16_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x16_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x16 vint8x16_lshift(vint8x16 vec1, vuint8x16 vec2)
 {
@@ -1380,6 +1532,8 @@
 }
 # define VINT8x16_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x16_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x16 vint8x16_rshift(vint8x16 vec1, vuint8x16 vec2)
 {
@@ -1388,6 +1542,8 @@
 }
 # define VINT8x16_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x16_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x16 vint8x16_lrshift(vint8x16 vec1, vuint8x16 vec2)
 {
@@ -1396,6 +1552,7 @@
 }
 # define VINT8x16_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT8x16_NOT_DEFINED
 VEC_FUNC_IMPL vint8x16 vint8x16_not(vint8x16 vec)
 {
@@ -1497,6 +1654,7 @@
 }
 # define VUINT8x16_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x16_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint8x16 vuint8x16_cmplt(vuint8x16 vec1, vuint8x16 vec2)
 {
@@ -1505,6 +1663,8 @@
 }
 # define VUINT8x16_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x16_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint8x16 vuint8x16_cmpeq(vuint8x16 vec1, vuint8x16 vec2)
 {
@@ -1513,6 +1673,8 @@
 }
 # define VUINT8x16_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x16_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint8x16 vuint8x16_cmpgt(vuint8x16 vec1, vuint8x16 vec2)
 {
@@ -1521,6 +1683,8 @@
 }
 # define VUINT8x16_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x16_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint8x16 vuint8x16_cmple(vuint8x16 vec1, vuint8x16 vec2)
 {
@@ -1529,6 +1693,8 @@
 }
 # define VUINT8x16_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x16_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint8x16 vuint8x16_cmpge(vuint8x16 vec1, vuint8x16 vec2)
 {
@@ -1537,6 +1703,8 @@
 }
 # define VUINT8x16_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x16_MIN_DEFINED
 VEC_FUNC_IMPL vuint8x16 vuint8x16_min(vuint8x16 vec1, vuint8x16 vec2)
 {
@@ -1547,6 +1715,8 @@
 }
 # define VUINT8x16_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x16_MAX_DEFINED
 VEC_FUNC_IMPL vuint8x16 vuint8x16_max(vuint8x16 vec1, vuint8x16 vec2)
 {
@@ -1557,14 +1727,19 @@
 }
 # define VUINT8x16_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x16_AVG_DEFINED
 VEC_FUNC_IMPL vuint8x16 vuint8x16_avg(vuint8x16 vec1, vuint8x16 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint8x16 ones = vint8x16_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT8x16_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x16_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x16 vuint8x16_lshift(vuint8x16 vec1, vuint8x16 vec2)
 {
@@ -1573,6 +1748,8 @@
 }
 # define VUINT8x16_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x16_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x16 vuint8x16_rshift(vuint8x16 vec1, vuint8x16 vec2)
 {
@@ -1581,6 +1758,8 @@
 }
 # define VUINT8x16_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x16_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x16 vuint8x16_lrshift(vuint8x16 vec1, vuint8x16 vec2)
 {
@@ -1589,6 +1768,7 @@
 }
 # define VUINT8x16_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT8x16_NOT_DEFINED
 VEC_FUNC_IMPL vuint8x16 vuint8x16_not(vuint8x16 vec)
 {
@@ -1690,6 +1870,7 @@
 }
 # define VINT8x32_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x32_CMPLT_DEFINED
 VEC_FUNC_IMPL vint8x32 vint8x32_cmplt(vint8x32 vec1, vint8x32 vec2)
 {
@@ -1698,6 +1879,8 @@
 }
 # define VINT8x32_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x32_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint8x32 vint8x32_cmpeq(vint8x32 vec1, vint8x32 vec2)
 {
@@ -1706,6 +1889,8 @@
 }
 # define VINT8x32_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x32_CMPGT_DEFINED
 VEC_FUNC_IMPL vint8x32 vint8x32_cmpgt(vint8x32 vec1, vint8x32 vec2)
 {
@@ -1714,6 +1899,8 @@
 }
 # define VINT8x32_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x32_CMPLE_DEFINED
 VEC_FUNC_IMPL vint8x32 vint8x32_cmple(vint8x32 vec1, vint8x32 vec2)
 {
@@ -1722,6 +1909,8 @@
 }
 # define VINT8x32_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x32_CMPGE_DEFINED
 VEC_FUNC_IMPL vint8x32 vint8x32_cmpge(vint8x32 vec1, vint8x32 vec2)
 {
@@ -1730,6 +1919,8 @@
 }
 # define VINT8x32_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x32_MIN_DEFINED
 VEC_FUNC_IMPL vint8x32 vint8x32_min(vint8x32 vec1, vint8x32 vec2)
 {
@@ -1740,6 +1931,8 @@
 }
 # define VINT8x32_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x32_MAX_DEFINED
 VEC_FUNC_IMPL vint8x32 vint8x32_max(vint8x32 vec1, vint8x32 vec2)
 {
@@ -1750,6 +1943,8 @@
 }
 # define VINT8x32_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x32_AVG_DEFINED
 VEC_FUNC_IMPL vint8x32 vint8x32_avg(vint8x32 vec1, vint8x32 vec2)
 {
@@ -1764,6 +1959,8 @@
 }
 # define VINT8x32_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x32_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x32 vint8x32_lshift(vint8x32 vec1, vuint8x32 vec2)
 {
@@ -1772,6 +1969,8 @@
 }
 # define VINT8x32_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x32_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x32 vint8x32_rshift(vint8x32 vec1, vuint8x32 vec2)
 {
@@ -1780,6 +1979,8 @@
 }
 # define VINT8x32_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x32_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x32 vint8x32_lrshift(vint8x32 vec1, vuint8x32 vec2)
 {
@@ -1788,6 +1989,7 @@
 }
 # define VINT8x32_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT8x32_NOT_DEFINED
 VEC_FUNC_IMPL vint8x32 vint8x32_not(vint8x32 vec)
 {
@@ -1889,6 +2091,7 @@
 }
 # define VUINT8x32_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x32_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint8x32 vuint8x32_cmplt(vuint8x32 vec1, vuint8x32 vec2)
 {
@@ -1897,6 +2100,8 @@
 }
 # define VUINT8x32_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x32_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint8x32 vuint8x32_cmpeq(vuint8x32 vec1, vuint8x32 vec2)
 {
@@ -1905,6 +2110,8 @@
 }
 # define VUINT8x32_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x32_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint8x32 vuint8x32_cmpgt(vuint8x32 vec1, vuint8x32 vec2)
 {
@@ -1913,6 +2120,8 @@
 }
 # define VUINT8x32_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x32_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint8x32 vuint8x32_cmple(vuint8x32 vec1, vuint8x32 vec2)
 {
@@ -1921,6 +2130,8 @@
 }
 # define VUINT8x32_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x32_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint8x32 vuint8x32_cmpge(vuint8x32 vec1, vuint8x32 vec2)
 {
@@ -1929,6 +2140,8 @@
 }
 # define VUINT8x32_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x32_MIN_DEFINED
 VEC_FUNC_IMPL vuint8x32 vuint8x32_min(vuint8x32 vec1, vuint8x32 vec2)
 {
@@ -1939,6 +2152,8 @@
 }
 # define VUINT8x32_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x32_MAX_DEFINED
 VEC_FUNC_IMPL vuint8x32 vuint8x32_max(vuint8x32 vec1, vuint8x32 vec2)
 {
@@ -1949,14 +2164,19 @@
 }
 # define VUINT8x32_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x32_AVG_DEFINED
 VEC_FUNC_IMPL vuint8x32 vuint8x32_avg(vuint8x32 vec1, vuint8x32 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint8x32 ones = vint8x32_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT8x32_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x32_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x32 vuint8x32_lshift(vuint8x32 vec1, vuint8x32 vec2)
 {
@@ -1965,6 +2185,8 @@
 }
 # define VUINT8x32_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x32_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x32 vuint8x32_rshift(vuint8x32 vec1, vuint8x32 vec2)
 {
@@ -1973,6 +2195,8 @@
 }
 # define VUINT8x32_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x32_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x32 vuint8x32_lrshift(vuint8x32 vec1, vuint8x32 vec2)
 {
@@ -1981,6 +2205,7 @@
 }
 # define VUINT8x32_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT8x32_NOT_DEFINED
 VEC_FUNC_IMPL vuint8x32 vuint8x32_not(vuint8x32 vec)
 {
@@ -2082,6 +2307,7 @@
 }
 # define VINT8x64_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x64_CMPLT_DEFINED
 VEC_FUNC_IMPL vint8x64 vint8x64_cmplt(vint8x64 vec1, vint8x64 vec2)
 {
@@ -2090,6 +2316,8 @@
 }
 # define VINT8x64_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x64_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint8x64 vint8x64_cmpeq(vint8x64 vec1, vint8x64 vec2)
 {
@@ -2098,6 +2326,8 @@
 }
 # define VINT8x64_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x64_CMPGT_DEFINED
 VEC_FUNC_IMPL vint8x64 vint8x64_cmpgt(vint8x64 vec1, vint8x64 vec2)
 {
@@ -2106,6 +2336,8 @@
 }
 # define VINT8x64_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x64_CMPLE_DEFINED
 VEC_FUNC_IMPL vint8x64 vint8x64_cmple(vint8x64 vec1, vint8x64 vec2)
 {
@@ -2114,6 +2346,8 @@
 }
 # define VINT8x64_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x64_CMPGE_DEFINED
 VEC_FUNC_IMPL vint8x64 vint8x64_cmpge(vint8x64 vec1, vint8x64 vec2)
 {
@@ -2122,6 +2356,8 @@
 }
 # define VINT8x64_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x64_MIN_DEFINED
 VEC_FUNC_IMPL vint8x64 vint8x64_min(vint8x64 vec1, vint8x64 vec2)
 {
@@ -2132,6 +2368,8 @@
 }
 # define VINT8x64_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x64_MAX_DEFINED
 VEC_FUNC_IMPL vint8x64 vint8x64_max(vint8x64 vec1, vint8x64 vec2)
 {
@@ -2142,6 +2380,8 @@
 }
 # define VINT8x64_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x64_AVG_DEFINED
 VEC_FUNC_IMPL vint8x64 vint8x64_avg(vint8x64 vec1, vint8x64 vec2)
 {
@@ -2156,6 +2396,8 @@
 }
 # define VINT8x64_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x64_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x64 vint8x64_lshift(vint8x64 vec1, vuint8x64 vec2)
 {
@@ -2164,6 +2406,8 @@
 }
 # define VINT8x64_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x64_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x64 vint8x64_rshift(vint8x64 vec1, vuint8x64 vec2)
 {
@@ -2172,6 +2416,8 @@
 }
 # define VINT8x64_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT8x64_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint8x64 vint8x64_lrshift(vint8x64 vec1, vuint8x64 vec2)
 {
@@ -2180,6 +2426,7 @@
 }
 # define VINT8x64_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT8x64_NOT_DEFINED
 VEC_FUNC_IMPL vint8x64 vint8x64_not(vint8x64 vec)
 {
@@ -2281,6 +2528,7 @@
 }
 # define VUINT8x64_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x64_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint8x64 vuint8x64_cmplt(vuint8x64 vec1, vuint8x64 vec2)
 {
@@ -2289,6 +2537,8 @@
 }
 # define VUINT8x64_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x64_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint8x64 vuint8x64_cmpeq(vuint8x64 vec1, vuint8x64 vec2)
 {
@@ -2297,6 +2547,8 @@
 }
 # define VUINT8x64_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x64_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint8x64 vuint8x64_cmpgt(vuint8x64 vec1, vuint8x64 vec2)
 {
@@ -2305,6 +2557,8 @@
 }
 # define VUINT8x64_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x64_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint8x64 vuint8x64_cmple(vuint8x64 vec1, vuint8x64 vec2)
 {
@@ -2313,6 +2567,8 @@
 }
 # define VUINT8x64_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x64_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint8x64 vuint8x64_cmpge(vuint8x64 vec1, vuint8x64 vec2)
 {
@@ -2321,6 +2577,8 @@
 }
 # define VUINT8x64_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x64_MIN_DEFINED
 VEC_FUNC_IMPL vuint8x64 vuint8x64_min(vuint8x64 vec1, vuint8x64 vec2)
 {
@@ -2331,6 +2589,8 @@
 }
 # define VUINT8x64_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x64_MAX_DEFINED
 VEC_FUNC_IMPL vuint8x64 vuint8x64_max(vuint8x64 vec1, vuint8x64 vec2)
 {
@@ -2341,14 +2601,19 @@
 }
 # define VUINT8x64_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x64_AVG_DEFINED
 VEC_FUNC_IMPL vuint8x64 vuint8x64_avg(vuint8x64 vec1, vuint8x64 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint8x64 ones = vint8x64_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT8x64_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x64_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x64 vuint8x64_lshift(vuint8x64 vec1, vuint8x64 vec2)
 {
@@ -2357,6 +2622,8 @@
 }
 # define VUINT8x64_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x64_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x64 vuint8x64_rshift(vuint8x64 vec1, vuint8x64 vec2)
 {
@@ -2365,6 +2632,8 @@
 }
 # define VUINT8x64_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT8x64_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint8x64 vuint8x64_lrshift(vuint8x64 vec1, vuint8x64 vec2)
 {
@@ -2373,6 +2642,7 @@
 }
 # define VUINT8x64_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT8x64_NOT_DEFINED
 VEC_FUNC_IMPL vuint8x64 vuint8x64_not(vuint8x64 vec)
 {
@@ -2474,6 +2744,7 @@
 }
 # define VINT16x2_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x2_CMPLT_DEFINED
 VEC_FUNC_IMPL vint16x2 vint16x2_cmplt(vint16x2 vec1, vint16x2 vec2)
 {
@@ -2482,6 +2753,8 @@
 }
 # define VINT16x2_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x2_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint16x2 vint16x2_cmpeq(vint16x2 vec1, vint16x2 vec2)
 {
@@ -2490,6 +2763,8 @@
 }
 # define VINT16x2_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x2_CMPGT_DEFINED
 VEC_FUNC_IMPL vint16x2 vint16x2_cmpgt(vint16x2 vec1, vint16x2 vec2)
 {
@@ -2498,6 +2773,8 @@
 }
 # define VINT16x2_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x2_CMPLE_DEFINED
 VEC_FUNC_IMPL vint16x2 vint16x2_cmple(vint16x2 vec1, vint16x2 vec2)
 {
@@ -2506,6 +2783,8 @@
 }
 # define VINT16x2_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x2_CMPGE_DEFINED
 VEC_FUNC_IMPL vint16x2 vint16x2_cmpge(vint16x2 vec1, vint16x2 vec2)
 {
@@ -2514,6 +2793,8 @@
 }
 # define VINT16x2_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x2_MIN_DEFINED
 VEC_FUNC_IMPL vint16x2 vint16x2_min(vint16x2 vec1, vint16x2 vec2)
 {
@@ -2524,6 +2805,8 @@
 }
 # define VINT16x2_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x2_MAX_DEFINED
 VEC_FUNC_IMPL vint16x2 vint16x2_max(vint16x2 vec1, vint16x2 vec2)
 {
@@ -2534,6 +2817,8 @@
 }
 # define VINT16x2_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x2_AVG_DEFINED
 VEC_FUNC_IMPL vint16x2 vint16x2_avg(vint16x2 vec1, vint16x2 vec2)
 {
@@ -2548,6 +2833,8 @@
 }
 # define VINT16x2_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x2_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint16x2 vint16x2_lshift(vint16x2 vec1, vuint16x2 vec2)
 {
@@ -2556,6 +2843,8 @@
 }
 # define VINT16x2_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x2_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint16x2 vint16x2_rshift(vint16x2 vec1, vuint16x2 vec2)
 {
@@ -2564,6 +2853,8 @@
 }
 # define VINT16x2_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x2_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint16x2 vint16x2_lrshift(vint16x2 vec1, vuint16x2 vec2)
 {
@@ -2572,6 +2863,7 @@
 }
 # define VINT16x2_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT16x2_NOT_DEFINED
 VEC_FUNC_IMPL vint16x2 vint16x2_not(vint16x2 vec)
 {
@@ -2673,6 +2965,7 @@
 }
 # define VUINT16x2_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x2_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint16x2 vuint16x2_cmplt(vuint16x2 vec1, vuint16x2 vec2)
 {
@@ -2681,6 +2974,8 @@
 }
 # define VUINT16x2_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x2_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint16x2 vuint16x2_cmpeq(vuint16x2 vec1, vuint16x2 vec2)
 {
@@ -2689,6 +2984,8 @@
 }
 # define VUINT16x2_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x2_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint16x2 vuint16x2_cmpgt(vuint16x2 vec1, vuint16x2 vec2)
 {
@@ -2697,6 +2994,8 @@
 }
 # define VUINT16x2_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x2_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint16x2 vuint16x2_cmple(vuint16x2 vec1, vuint16x2 vec2)
 {
@@ -2705,6 +3004,8 @@
 }
 # define VUINT16x2_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x2_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint16x2 vuint16x2_cmpge(vuint16x2 vec1, vuint16x2 vec2)
 {
@@ -2713,6 +3014,8 @@
 }
 # define VUINT16x2_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x2_MIN_DEFINED
 VEC_FUNC_IMPL vuint16x2 vuint16x2_min(vuint16x2 vec1, vuint16x2 vec2)
 {
@@ -2723,6 +3026,8 @@
 }
 # define VUINT16x2_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x2_MAX_DEFINED
 VEC_FUNC_IMPL vuint16x2 vuint16x2_max(vuint16x2 vec1, vuint16x2 vec2)
 {
@@ -2733,14 +3038,19 @@
 }
 # define VUINT16x2_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x2_AVG_DEFINED
 VEC_FUNC_IMPL vuint16x2 vuint16x2_avg(vuint16x2 vec1, vuint16x2 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint16x2 ones = vint16x2_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT16x2_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x2_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint16x2 vuint16x2_lshift(vuint16x2 vec1, vuint16x2 vec2)
 {
@@ -2749,6 +3059,8 @@
 }
 # define VUINT16x2_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x2_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint16x2 vuint16x2_rshift(vuint16x2 vec1, vuint16x2 vec2)
 {
@@ -2757,6 +3069,8 @@
 }
 # define VUINT16x2_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x2_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint16x2 vuint16x2_lrshift(vuint16x2 vec1, vuint16x2 vec2)
 {
@@ -2765,6 +3079,7 @@
 }
 # define VUINT16x2_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT16x2_NOT_DEFINED
 VEC_FUNC_IMPL vuint16x2 vuint16x2_not(vuint16x2 vec)
 {
@@ -2866,6 +3181,7 @@
 }
 # define VINT16x4_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x4_CMPLT_DEFINED
 VEC_FUNC_IMPL vint16x4 vint16x4_cmplt(vint16x4 vec1, vint16x4 vec2)
 {
@@ -2874,6 +3190,8 @@
 }
 # define VINT16x4_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x4_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint16x4 vint16x4_cmpeq(vint16x4 vec1, vint16x4 vec2)
 {
@@ -2882,6 +3200,8 @@
 }
 # define VINT16x4_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x4_CMPGT_DEFINED
 VEC_FUNC_IMPL vint16x4 vint16x4_cmpgt(vint16x4 vec1, vint16x4 vec2)
 {
@@ -2890,6 +3210,8 @@
 }
 # define VINT16x4_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x4_CMPLE_DEFINED
 VEC_FUNC_IMPL vint16x4 vint16x4_cmple(vint16x4 vec1, vint16x4 vec2)
 {
@@ -2898,6 +3220,8 @@
 }
 # define VINT16x4_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x4_CMPGE_DEFINED
 VEC_FUNC_IMPL vint16x4 vint16x4_cmpge(vint16x4 vec1, vint16x4 vec2)
 {
@@ -2906,6 +3230,8 @@
 }
 # define VINT16x4_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x4_MIN_DEFINED
 VEC_FUNC_IMPL vint16x4 vint16x4_min(vint16x4 vec1, vint16x4 vec2)
 {
@@ -2916,6 +3242,8 @@
 }
 # define VINT16x4_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x4_MAX_DEFINED
 VEC_FUNC_IMPL vint16x4 vint16x4_max(vint16x4 vec1, vint16x4 vec2)
 {
@@ -2926,6 +3254,8 @@
 }
 # define VINT16x4_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x4_AVG_DEFINED
 VEC_FUNC_IMPL vint16x4 vint16x4_avg(vint16x4 vec1, vint16x4 vec2)
 {
@@ -2940,6 +3270,8 @@
 }
 # define VINT16x4_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x4_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint16x4 vint16x4_lshift(vint16x4 vec1, vuint16x4 vec2)
 {
@@ -2948,6 +3280,8 @@
 }
 # define VINT16x4_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x4_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint16x4 vint16x4_rshift(vint16x4 vec1, vuint16x4 vec2)
 {
@@ -2956,6 +3290,8 @@
 }
 # define VINT16x4_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x4_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint16x4 vint16x4_lrshift(vint16x4 vec1, vuint16x4 vec2)
 {
@@ -2964,6 +3300,7 @@
 }
 # define VINT16x4_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT16x4_NOT_DEFINED
 VEC_FUNC_IMPL vint16x4 vint16x4_not(vint16x4 vec)
 {
@@ -3065,6 +3402,7 @@
 }
 # define VUINT16x4_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x4_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint16x4 vuint16x4_cmplt(vuint16x4 vec1, vuint16x4 vec2)
 {
@@ -3073,6 +3411,8 @@
 }
 # define VUINT16x4_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x4_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint16x4 vuint16x4_cmpeq(vuint16x4 vec1, vuint16x4 vec2)
 {
@@ -3081,6 +3421,8 @@
 }
 # define VUINT16x4_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x4_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint16x4 vuint16x4_cmpgt(vuint16x4 vec1, vuint16x4 vec2)
 {
@@ -3089,6 +3431,8 @@
 }
 # define VUINT16x4_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x4_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint16x4 vuint16x4_cmple(vuint16x4 vec1, vuint16x4 vec2)
 {
@@ -3097,6 +3441,8 @@
 }
 # define VUINT16x4_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x4_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint16x4 vuint16x4_cmpge(vuint16x4 vec1, vuint16x4 vec2)
 {
@@ -3105,6 +3451,8 @@
 }
 # define VUINT16x4_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x4_MIN_DEFINED
 VEC_FUNC_IMPL vuint16x4 vuint16x4_min(vuint16x4 vec1, vuint16x4 vec2)
 {
@@ -3115,6 +3463,8 @@
 }
 # define VUINT16x4_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x4_MAX_DEFINED
 VEC_FUNC_IMPL vuint16x4 vuint16x4_max(vuint16x4 vec1, vuint16x4 vec2)
 {
@@ -3125,14 +3475,19 @@
 }
 # define VUINT16x4_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x4_AVG_DEFINED
 VEC_FUNC_IMPL vuint16x4 vuint16x4_avg(vuint16x4 vec1, vuint16x4 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint16x4 ones = vint16x4_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT16x4_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x4_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint16x4 vuint16x4_lshift(vuint16x4 vec1, vuint16x4 vec2)
 {
@@ -3141,6 +3496,8 @@
 }
 # define VUINT16x4_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x4_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint16x4 vuint16x4_rshift(vuint16x4 vec1, vuint16x4 vec2)
 {
@@ -3149,6 +3506,8 @@
 }
 # define VUINT16x4_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x4_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint16x4 vuint16x4_lrshift(vuint16x4 vec1, vuint16x4 vec2)
 {
@@ -3157,6 +3516,7 @@
 }
 # define VUINT16x4_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT16x4_NOT_DEFINED
 VEC_FUNC_IMPL vuint16x4 vuint16x4_not(vuint16x4 vec)
 {
@@ -3258,6 +3618,7 @@
 }
 # define VINT16x8_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x8_CMPLT_DEFINED
 VEC_FUNC_IMPL vint16x8 vint16x8_cmplt(vint16x8 vec1, vint16x8 vec2)
 {
@@ -3266,6 +3627,8 @@
 }
 # define VINT16x8_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x8_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint16x8 vint16x8_cmpeq(vint16x8 vec1, vint16x8 vec2)
 {
@@ -3274,6 +3637,8 @@
 }
 # define VINT16x8_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x8_CMPGT_DEFINED
 VEC_FUNC_IMPL vint16x8 vint16x8_cmpgt(vint16x8 vec1, vint16x8 vec2)
 {
@@ -3282,6 +3647,8 @@
 }
 # define VINT16x8_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x8_CMPLE_DEFINED
 VEC_FUNC_IMPL vint16x8 vint16x8_cmple(vint16x8 vec1, vint16x8 vec2)
 {
@@ -3290,6 +3657,8 @@
 }
 # define VINT16x8_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x8_CMPGE_DEFINED
 VEC_FUNC_IMPL vint16x8 vint16x8_cmpge(vint16x8 vec1, vint16x8 vec2)
 {
@@ -3298,6 +3667,8 @@
 }
 # define VINT16x8_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x8_MIN_DEFINED
 VEC_FUNC_IMPL vint16x8 vint16x8_min(vint16x8 vec1, vint16x8 vec2)
 {
@@ -3308,6 +3679,8 @@
 }
 # define VINT16x8_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x8_MAX_DEFINED
 VEC_FUNC_IMPL vint16x8 vint16x8_max(vint16x8 vec1, vint16x8 vec2)
 {
@@ -3318,6 +3691,8 @@
 }
 # define VINT16x8_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x8_AVG_DEFINED
 VEC_FUNC_IMPL vint16x8 vint16x8_avg(vint16x8 vec1, vint16x8 vec2)
 {
@@ -3332,6 +3707,8 @@
 }
 # define VINT16x8_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x8_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint16x8 vint16x8_lshift(vint16x8 vec1, vuint16x8 vec2)
 {
@@ -3340,6 +3717,8 @@
 }
 # define VINT16x8_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x8_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint16x8 vint16x8_rshift(vint16x8 vec1, vuint16x8 vec2)
 {
@@ -3348,6 +3727,8 @@
 }
 # define VINT16x8_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x8_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint16x8 vint16x8_lrshift(vint16x8 vec1, vuint16x8 vec2)
 {
@@ -3356,6 +3737,7 @@
 }
 # define VINT16x8_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT16x8_NOT_DEFINED
 VEC_FUNC_IMPL vint16x8 vint16x8_not(vint16x8 vec)
 {
@@ -3457,6 +3839,7 @@
 }
 # define VUINT16x8_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x8_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint16x8 vuint16x8_cmplt(vuint16x8 vec1, vuint16x8 vec2)
 {
@@ -3465,6 +3848,8 @@
 }
 # define VUINT16x8_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x8_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint16x8 vuint16x8_cmpeq(vuint16x8 vec1, vuint16x8 vec2)
 {
@@ -3473,6 +3858,8 @@
 }
 # define VUINT16x8_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x8_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint16x8 vuint16x8_cmpgt(vuint16x8 vec1, vuint16x8 vec2)
 {
@@ -3481,6 +3868,8 @@
 }
 # define VUINT16x8_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x8_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint16x8 vuint16x8_cmple(vuint16x8 vec1, vuint16x8 vec2)
 {
@@ -3489,6 +3878,8 @@
 }
 # define VUINT16x8_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x8_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint16x8 vuint16x8_cmpge(vuint16x8 vec1, vuint16x8 vec2)
 {
@@ -3497,6 +3888,8 @@
 }
 # define VUINT16x8_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x8_MIN_DEFINED
 VEC_FUNC_IMPL vuint16x8 vuint16x8_min(vuint16x8 vec1, vuint16x8 vec2)
 {
@@ -3507,6 +3900,8 @@
 }
 # define VUINT16x8_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x8_MAX_DEFINED
 VEC_FUNC_IMPL vuint16x8 vuint16x8_max(vuint16x8 vec1, vuint16x8 vec2)
 {
@@ -3517,14 +3912,19 @@
 }
 # define VUINT16x8_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x8_AVG_DEFINED
 VEC_FUNC_IMPL vuint16x8 vuint16x8_avg(vuint16x8 vec1, vuint16x8 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint16x8 ones = vint16x8_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT16x8_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x8_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint16x8 vuint16x8_lshift(vuint16x8 vec1, vuint16x8 vec2)
 {
@@ -3533,6 +3933,8 @@
 }
 # define VUINT16x8_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x8_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint16x8 vuint16x8_rshift(vuint16x8 vec1, vuint16x8 vec2)
 {
@@ -3541,6 +3943,8 @@
 }
 # define VUINT16x8_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x8_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint16x8 vuint16x8_lrshift(vuint16x8 vec1, vuint16x8 vec2)
 {
@@ -3549,6 +3953,7 @@
 }
 # define VUINT16x8_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT16x8_NOT_DEFINED
 VEC_FUNC_IMPL vuint16x8 vuint16x8_not(vuint16x8 vec)
 {
@@ -3650,6 +4055,7 @@
 }
 # define VINT16x16_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x16_CMPLT_DEFINED
 VEC_FUNC_IMPL vint16x16 vint16x16_cmplt(vint16x16 vec1, vint16x16 vec2)
 {
@@ -3658,6 +4064,8 @@
 }
 # define VINT16x16_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x16_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint16x16 vint16x16_cmpeq(vint16x16 vec1, vint16x16 vec2)
 {
@@ -3666,6 +4074,8 @@
 }
 # define VINT16x16_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x16_CMPGT_DEFINED
 VEC_FUNC_IMPL vint16x16 vint16x16_cmpgt(vint16x16 vec1, vint16x16 vec2)
 {
@@ -3674,6 +4084,8 @@
 }
 # define VINT16x16_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x16_CMPLE_DEFINED
 VEC_FUNC_IMPL vint16x16 vint16x16_cmple(vint16x16 vec1, vint16x16 vec2)
 {
@@ -3682,6 +4094,8 @@
 }
 # define VINT16x16_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x16_CMPGE_DEFINED
 VEC_FUNC_IMPL vint16x16 vint16x16_cmpge(vint16x16 vec1, vint16x16 vec2)
 {
@@ -3690,6 +4104,8 @@
 }
 # define VINT16x16_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x16_MIN_DEFINED
 VEC_FUNC_IMPL vint16x16 vint16x16_min(vint16x16 vec1, vint16x16 vec2)
 {
@@ -3700,6 +4116,8 @@
 }
 # define VINT16x16_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x16_MAX_DEFINED
 VEC_FUNC_IMPL vint16x16 vint16x16_max(vint16x16 vec1, vint16x16 vec2)
 {
@@ -3710,6 +4128,8 @@
 }
 # define VINT16x16_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x16_AVG_DEFINED
 VEC_FUNC_IMPL vint16x16 vint16x16_avg(vint16x16 vec1, vint16x16 vec2)
 {
@@ -3724,6 +4144,8 @@
 }
 # define VINT16x16_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x16_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint16x16 vint16x16_lshift(vint16x16 vec1, vuint16x16 vec2)
 {
@@ -3732,6 +4154,8 @@
 }
 # define VINT16x16_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x16_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint16x16 vint16x16_rshift(vint16x16 vec1, vuint16x16 vec2)
 {
@@ -3740,6 +4164,8 @@
 }
 # define VINT16x16_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x16_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint16x16 vint16x16_lrshift(vint16x16 vec1, vuint16x16 vec2)
 {
@@ -3748,6 +4174,7 @@
 }
 # define VINT16x16_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT16x16_NOT_DEFINED
 VEC_FUNC_IMPL vint16x16 vint16x16_not(vint16x16 vec)
 {
@@ -3849,6 +4276,7 @@
 }
 # define VUINT16x16_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x16_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint16x16 vuint16x16_cmplt(vuint16x16 vec1, vuint16x16 vec2)
 {
@@ -3857,6 +4285,8 @@
 }
 # define VUINT16x16_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x16_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint16x16 vuint16x16_cmpeq(vuint16x16 vec1, vuint16x16 vec2)
 {
@@ -3865,6 +4295,8 @@
 }
 # define VUINT16x16_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x16_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint16x16 vuint16x16_cmpgt(vuint16x16 vec1, vuint16x16 vec2)
 {
@@ -3873,6 +4305,8 @@
 }
 # define VUINT16x16_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x16_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint16x16 vuint16x16_cmple(vuint16x16 vec1, vuint16x16 vec2)
 {
@@ -3881,6 +4315,8 @@
 }
 # define VUINT16x16_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x16_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint16x16 vuint16x16_cmpge(vuint16x16 vec1, vuint16x16 vec2)
 {
@@ -3889,6 +4325,8 @@
 }
 # define VUINT16x16_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x16_MIN_DEFINED
 VEC_FUNC_IMPL vuint16x16 vuint16x16_min(vuint16x16 vec1, vuint16x16 vec2)
 {
@@ -3899,6 +4337,8 @@
 }
 # define VUINT16x16_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x16_MAX_DEFINED
 VEC_FUNC_IMPL vuint16x16 vuint16x16_max(vuint16x16 vec1, vuint16x16 vec2)
 {
@@ -3909,14 +4349,19 @@
 }
 # define VUINT16x16_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x16_AVG_DEFINED
 VEC_FUNC_IMPL vuint16x16 vuint16x16_avg(vuint16x16 vec1, vuint16x16 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint16x16 ones = vint16x16_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT16x16_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x16_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint16x16 vuint16x16_lshift(vuint16x16 vec1, vuint16x16 vec2)
 {
@@ -3925,6 +4370,8 @@
 }
 # define VUINT16x16_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x16_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint16x16 vuint16x16_rshift(vuint16x16 vec1, vuint16x16 vec2)
 {
@@ -3933,6 +4380,8 @@
 }
 # define VUINT16x16_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x16_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint16x16 vuint16x16_lrshift(vuint16x16 vec1, vuint16x16 vec2)
 {
@@ -3941,6 +4390,7 @@
 }
 # define VUINT16x16_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT16x16_NOT_DEFINED
 VEC_FUNC_IMPL vuint16x16 vuint16x16_not(vuint16x16 vec)
 {
@@ -4042,6 +4492,7 @@
 }
 # define VINT16x32_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x32_CMPLT_DEFINED
 VEC_FUNC_IMPL vint16x32 vint16x32_cmplt(vint16x32 vec1, vint16x32 vec2)
 {
@@ -4050,6 +4501,8 @@
 }
 # define VINT16x32_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x32_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint16x32 vint16x32_cmpeq(vint16x32 vec1, vint16x32 vec2)
 {
@@ -4058,6 +4511,8 @@
 }
 # define VINT16x32_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x32_CMPGT_DEFINED
 VEC_FUNC_IMPL vint16x32 vint16x32_cmpgt(vint16x32 vec1, vint16x32 vec2)
 {
@@ -4066,6 +4521,8 @@
 }
 # define VINT16x32_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x32_CMPLE_DEFINED
 VEC_FUNC_IMPL vint16x32 vint16x32_cmple(vint16x32 vec1, vint16x32 vec2)
 {
@@ -4074,6 +4531,8 @@
 }
 # define VINT16x32_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x32_CMPGE_DEFINED
 VEC_FUNC_IMPL vint16x32 vint16x32_cmpge(vint16x32 vec1, vint16x32 vec2)
 {
@@ -4082,6 +4541,8 @@
 }
 # define VINT16x32_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x32_MIN_DEFINED
 VEC_FUNC_IMPL vint16x32 vint16x32_min(vint16x32 vec1, vint16x32 vec2)
 {
@@ -4092,6 +4553,8 @@
 }
 # define VINT16x32_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x32_MAX_DEFINED
 VEC_FUNC_IMPL vint16x32 vint16x32_max(vint16x32 vec1, vint16x32 vec2)
 {
@@ -4102,6 +4565,8 @@
 }
 # define VINT16x32_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x32_AVG_DEFINED
 VEC_FUNC_IMPL vint16x32 vint16x32_avg(vint16x32 vec1, vint16x32 vec2)
 {
@@ -4116,6 +4581,8 @@
 }
 # define VINT16x32_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x32_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint16x32 vint16x32_lshift(vint16x32 vec1, vuint16x32 vec2)
 {
@@ -4124,6 +4591,8 @@
 }
 # define VINT16x32_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x32_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint16x32 vint16x32_rshift(vint16x32 vec1, vuint16x32 vec2)
 {
@@ -4132,6 +4601,8 @@
 }
 # define VINT16x32_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT16x32_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint16x32 vint16x32_lrshift(vint16x32 vec1, vuint16x32 vec2)
 {
@@ -4140,6 +4611,7 @@
 }
 # define VINT16x32_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT16x32_NOT_DEFINED
 VEC_FUNC_IMPL vint16x32 vint16x32_not(vint16x32 vec)
 {
@@ -4241,6 +4713,7 @@
 }
 # define VUINT16x32_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x32_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint16x32 vuint16x32_cmplt(vuint16x32 vec1, vuint16x32 vec2)
 {
@@ -4249,6 +4722,8 @@
 }
 # define VUINT16x32_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x32_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint16x32 vuint16x32_cmpeq(vuint16x32 vec1, vuint16x32 vec2)
 {
@@ -4257,6 +4732,8 @@
 }
 # define VUINT16x32_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x32_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint16x32 vuint16x32_cmpgt(vuint16x32 vec1, vuint16x32 vec2)
 {
@@ -4265,6 +4742,8 @@
 }
 # define VUINT16x32_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x32_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint16x32 vuint16x32_cmple(vuint16x32 vec1, vuint16x32 vec2)
 {
@@ -4273,6 +4752,8 @@
 }
 # define VUINT16x32_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x32_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint16x32 vuint16x32_cmpge(vuint16x32 vec1, vuint16x32 vec2)
 {
@@ -4281,6 +4762,8 @@
 }
 # define VUINT16x32_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x32_MIN_DEFINED
 VEC_FUNC_IMPL vuint16x32 vuint16x32_min(vuint16x32 vec1, vuint16x32 vec2)
 {
@@ -4291,6 +4774,8 @@
 }
 # define VUINT16x32_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x32_MAX_DEFINED
 VEC_FUNC_IMPL vuint16x32 vuint16x32_max(vuint16x32 vec1, vuint16x32 vec2)
 {
@@ -4301,14 +4786,19 @@
 }
 # define VUINT16x32_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x32_AVG_DEFINED
 VEC_FUNC_IMPL vuint16x32 vuint16x32_avg(vuint16x32 vec1, vuint16x32 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint16x32 ones = vint16x32_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT16x32_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x32_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint16x32 vuint16x32_lshift(vuint16x32 vec1, vuint16x32 vec2)
 {
@@ -4317,6 +4807,8 @@
 }
 # define VUINT16x32_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x32_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint16x32 vuint16x32_rshift(vuint16x32 vec1, vuint16x32 vec2)
 {
@@ -4325,6 +4817,8 @@
 }
 # define VUINT16x32_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT16x32_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint16x32 vuint16x32_lrshift(vuint16x32 vec1, vuint16x32 vec2)
 {
@@ -4333,6 +4827,7 @@
 }
 # define VUINT16x32_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT16x32_NOT_DEFINED
 VEC_FUNC_IMPL vuint16x32 vuint16x32_not(vuint16x32 vec)
 {
@@ -4434,6 +4929,7 @@
 }
 # define VINT32x2_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x2_CMPLT_DEFINED
 VEC_FUNC_IMPL vint32x2 vint32x2_cmplt(vint32x2 vec1, vint32x2 vec2)
 {
@@ -4442,6 +4938,8 @@
 }
 # define VINT32x2_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x2_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint32x2 vint32x2_cmpeq(vint32x2 vec1, vint32x2 vec2)
 {
@@ -4450,6 +4948,8 @@
 }
 # define VINT32x2_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x2_CMPGT_DEFINED
 VEC_FUNC_IMPL vint32x2 vint32x2_cmpgt(vint32x2 vec1, vint32x2 vec2)
 {
@@ -4458,6 +4958,8 @@
 }
 # define VINT32x2_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x2_CMPLE_DEFINED
 VEC_FUNC_IMPL vint32x2 vint32x2_cmple(vint32x2 vec1, vint32x2 vec2)
 {
@@ -4466,6 +4968,8 @@
 }
 # define VINT32x2_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x2_CMPGE_DEFINED
 VEC_FUNC_IMPL vint32x2 vint32x2_cmpge(vint32x2 vec1, vint32x2 vec2)
 {
@@ -4474,6 +4978,8 @@
 }
 # define VINT32x2_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x2_MIN_DEFINED
 VEC_FUNC_IMPL vint32x2 vint32x2_min(vint32x2 vec1, vint32x2 vec2)
 {
@@ -4484,6 +4990,8 @@
 }
 # define VINT32x2_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x2_MAX_DEFINED
 VEC_FUNC_IMPL vint32x2 vint32x2_max(vint32x2 vec1, vint32x2 vec2)
 {
@@ -4494,6 +5002,8 @@
 }
 # define VINT32x2_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x2_AVG_DEFINED
 VEC_FUNC_IMPL vint32x2 vint32x2_avg(vint32x2 vec1, vint32x2 vec2)
 {
@@ -4508,6 +5018,8 @@
 }
 # define VINT32x2_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x2_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint32x2 vint32x2_lshift(vint32x2 vec1, vuint32x2 vec2)
 {
@@ -4516,6 +5028,8 @@
 }
 # define VINT32x2_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x2_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint32x2 vint32x2_rshift(vint32x2 vec1, vuint32x2 vec2)
 {
@@ -4524,6 +5038,8 @@
 }
 # define VINT32x2_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x2_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint32x2 vint32x2_lrshift(vint32x2 vec1, vuint32x2 vec2)
 {
@@ -4532,6 +5048,7 @@
 }
 # define VINT32x2_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT32x2_NOT_DEFINED
 VEC_FUNC_IMPL vint32x2 vint32x2_not(vint32x2 vec)
 {
@@ -4633,6 +5150,7 @@
 }
 # define VUINT32x2_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x2_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint32x2 vuint32x2_cmplt(vuint32x2 vec1, vuint32x2 vec2)
 {
@@ -4641,6 +5159,8 @@
 }
 # define VUINT32x2_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x2_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint32x2 vuint32x2_cmpeq(vuint32x2 vec1, vuint32x2 vec2)
 {
@@ -4649,6 +5169,8 @@
 }
 # define VUINT32x2_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x2_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint32x2 vuint32x2_cmpgt(vuint32x2 vec1, vuint32x2 vec2)
 {
@@ -4657,6 +5179,8 @@
 }
 # define VUINT32x2_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x2_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint32x2 vuint32x2_cmple(vuint32x2 vec1, vuint32x2 vec2)
 {
@@ -4665,6 +5189,8 @@
 }
 # define VUINT32x2_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x2_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint32x2 vuint32x2_cmpge(vuint32x2 vec1, vuint32x2 vec2)
 {
@@ -4673,6 +5199,8 @@
 }
 # define VUINT32x2_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x2_MIN_DEFINED
 VEC_FUNC_IMPL vuint32x2 vuint32x2_min(vuint32x2 vec1, vuint32x2 vec2)
 {
@@ -4683,6 +5211,8 @@
 }
 # define VUINT32x2_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x2_MAX_DEFINED
 VEC_FUNC_IMPL vuint32x2 vuint32x2_max(vuint32x2 vec1, vuint32x2 vec2)
 {
@@ -4693,14 +5223,19 @@
 }
 # define VUINT32x2_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x2_AVG_DEFINED
 VEC_FUNC_IMPL vuint32x2 vuint32x2_avg(vuint32x2 vec1, vuint32x2 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint32x2 ones = vint32x2_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT32x2_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x2_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint32x2 vuint32x2_lshift(vuint32x2 vec1, vuint32x2 vec2)
 {
@@ -4709,6 +5244,8 @@
 }
 # define VUINT32x2_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x2_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint32x2 vuint32x2_rshift(vuint32x2 vec1, vuint32x2 vec2)
 {
@@ -4717,6 +5254,8 @@
 }
 # define VUINT32x2_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x2_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint32x2 vuint32x2_lrshift(vuint32x2 vec1, vuint32x2 vec2)
 {
@@ -4725,6 +5264,7 @@
 }
 # define VUINT32x2_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT32x2_NOT_DEFINED
 VEC_FUNC_IMPL vuint32x2 vuint32x2_not(vuint32x2 vec)
 {
@@ -4826,6 +5366,7 @@
 }
 # define VINT32x4_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x4_CMPLT_DEFINED
 VEC_FUNC_IMPL vint32x4 vint32x4_cmplt(vint32x4 vec1, vint32x4 vec2)
 {
@@ -4834,6 +5375,8 @@
 }
 # define VINT32x4_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x4_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint32x4 vint32x4_cmpeq(vint32x4 vec1, vint32x4 vec2)
 {
@@ -4842,6 +5385,8 @@
 }
 # define VINT32x4_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x4_CMPGT_DEFINED
 VEC_FUNC_IMPL vint32x4 vint32x4_cmpgt(vint32x4 vec1, vint32x4 vec2)
 {
@@ -4850,6 +5395,8 @@
 }
 # define VINT32x4_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x4_CMPLE_DEFINED
 VEC_FUNC_IMPL vint32x4 vint32x4_cmple(vint32x4 vec1, vint32x4 vec2)
 {
@@ -4858,6 +5405,8 @@
 }
 # define VINT32x4_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x4_CMPGE_DEFINED
 VEC_FUNC_IMPL vint32x4 vint32x4_cmpge(vint32x4 vec1, vint32x4 vec2)
 {
@@ -4866,6 +5415,8 @@
 }
 # define VINT32x4_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x4_MIN_DEFINED
 VEC_FUNC_IMPL vint32x4 vint32x4_min(vint32x4 vec1, vint32x4 vec2)
 {
@@ -4876,6 +5427,8 @@
 }
 # define VINT32x4_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x4_MAX_DEFINED
 VEC_FUNC_IMPL vint32x4 vint32x4_max(vint32x4 vec1, vint32x4 vec2)
 {
@@ -4886,6 +5439,8 @@
 }
 # define VINT32x4_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x4_AVG_DEFINED
 VEC_FUNC_IMPL vint32x4 vint32x4_avg(vint32x4 vec1, vint32x4 vec2)
 {
@@ -4900,6 +5455,8 @@
 }
 # define VINT32x4_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x4_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint32x4 vint32x4_lshift(vint32x4 vec1, vuint32x4 vec2)
 {
@@ -4908,6 +5465,8 @@
 }
 # define VINT32x4_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x4_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint32x4 vint32x4_rshift(vint32x4 vec1, vuint32x4 vec2)
 {
@@ -4916,6 +5475,8 @@
 }
 # define VINT32x4_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x4_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint32x4 vint32x4_lrshift(vint32x4 vec1, vuint32x4 vec2)
 {
@@ -4924,6 +5485,7 @@
 }
 # define VINT32x4_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT32x4_NOT_DEFINED
 VEC_FUNC_IMPL vint32x4 vint32x4_not(vint32x4 vec)
 {
@@ -5025,6 +5587,7 @@
 }
 # define VUINT32x4_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x4_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint32x4 vuint32x4_cmplt(vuint32x4 vec1, vuint32x4 vec2)
 {
@@ -5033,6 +5596,8 @@
 }
 # define VUINT32x4_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x4_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint32x4 vuint32x4_cmpeq(vuint32x4 vec1, vuint32x4 vec2)
 {
@@ -5041,6 +5606,8 @@
 }
 # define VUINT32x4_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x4_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint32x4 vuint32x4_cmpgt(vuint32x4 vec1, vuint32x4 vec2)
 {
@@ -5049,6 +5616,8 @@
 }
 # define VUINT32x4_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x4_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint32x4 vuint32x4_cmple(vuint32x4 vec1, vuint32x4 vec2)
 {
@@ -5057,6 +5626,8 @@
 }
 # define VUINT32x4_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x4_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint32x4 vuint32x4_cmpge(vuint32x4 vec1, vuint32x4 vec2)
 {
@@ -5065,6 +5636,8 @@
 }
 # define VUINT32x4_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x4_MIN_DEFINED
 VEC_FUNC_IMPL vuint32x4 vuint32x4_min(vuint32x4 vec1, vuint32x4 vec2)
 {
@@ -5075,6 +5648,8 @@
 }
 # define VUINT32x4_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x4_MAX_DEFINED
 VEC_FUNC_IMPL vuint32x4 vuint32x4_max(vuint32x4 vec1, vuint32x4 vec2)
 {
@@ -5085,14 +5660,19 @@
 }
 # define VUINT32x4_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x4_AVG_DEFINED
 VEC_FUNC_IMPL vuint32x4 vuint32x4_avg(vuint32x4 vec1, vuint32x4 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint32x4 ones = vint32x4_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT32x4_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x4_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint32x4 vuint32x4_lshift(vuint32x4 vec1, vuint32x4 vec2)
 {
@@ -5101,6 +5681,8 @@
 }
 # define VUINT32x4_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x4_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint32x4 vuint32x4_rshift(vuint32x4 vec1, vuint32x4 vec2)
 {
@@ -5109,6 +5691,8 @@
 }
 # define VUINT32x4_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x4_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint32x4 vuint32x4_lrshift(vuint32x4 vec1, vuint32x4 vec2)
 {
@@ -5117,6 +5701,7 @@
 }
 # define VUINT32x4_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT32x4_NOT_DEFINED
 VEC_FUNC_IMPL vuint32x4 vuint32x4_not(vuint32x4 vec)
 {
@@ -5218,6 +5803,7 @@
 }
 # define VINT32x8_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x8_CMPLT_DEFINED
 VEC_FUNC_IMPL vint32x8 vint32x8_cmplt(vint32x8 vec1, vint32x8 vec2)
 {
@@ -5226,6 +5812,8 @@
 }
 # define VINT32x8_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x8_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint32x8 vint32x8_cmpeq(vint32x8 vec1, vint32x8 vec2)
 {
@@ -5234,6 +5822,8 @@
 }
 # define VINT32x8_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x8_CMPGT_DEFINED
 VEC_FUNC_IMPL vint32x8 vint32x8_cmpgt(vint32x8 vec1, vint32x8 vec2)
 {
@@ -5242,6 +5832,8 @@
 }
 # define VINT32x8_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x8_CMPLE_DEFINED
 VEC_FUNC_IMPL vint32x8 vint32x8_cmple(vint32x8 vec1, vint32x8 vec2)
 {
@@ -5250,6 +5842,8 @@
 }
 # define VINT32x8_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x8_CMPGE_DEFINED
 VEC_FUNC_IMPL vint32x8 vint32x8_cmpge(vint32x8 vec1, vint32x8 vec2)
 {
@@ -5258,6 +5852,8 @@
 }
 # define VINT32x8_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x8_MIN_DEFINED
 VEC_FUNC_IMPL vint32x8 vint32x8_min(vint32x8 vec1, vint32x8 vec2)
 {
@@ -5268,6 +5864,8 @@
 }
 # define VINT32x8_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x8_MAX_DEFINED
 VEC_FUNC_IMPL vint32x8 vint32x8_max(vint32x8 vec1, vint32x8 vec2)
 {
@@ -5278,6 +5876,8 @@
 }
 # define VINT32x8_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x8_AVG_DEFINED
 VEC_FUNC_IMPL vint32x8 vint32x8_avg(vint32x8 vec1, vint32x8 vec2)
 {
@@ -5292,6 +5892,8 @@
 }
 # define VINT32x8_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x8_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint32x8 vint32x8_lshift(vint32x8 vec1, vuint32x8 vec2)
 {
@@ -5300,6 +5902,8 @@
 }
 # define VINT32x8_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x8_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint32x8 vint32x8_rshift(vint32x8 vec1, vuint32x8 vec2)
 {
@@ -5308,6 +5912,8 @@
 }
 # define VINT32x8_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x8_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint32x8 vint32x8_lrshift(vint32x8 vec1, vuint32x8 vec2)
 {
@@ -5316,6 +5922,7 @@
 }
 # define VINT32x8_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT32x8_NOT_DEFINED
 VEC_FUNC_IMPL vint32x8 vint32x8_not(vint32x8 vec)
 {
@@ -5417,6 +6024,7 @@
 }
 # define VUINT32x8_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x8_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint32x8 vuint32x8_cmplt(vuint32x8 vec1, vuint32x8 vec2)
 {
@@ -5425,6 +6033,8 @@
 }
 # define VUINT32x8_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x8_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint32x8 vuint32x8_cmpeq(vuint32x8 vec1, vuint32x8 vec2)
 {
@@ -5433,6 +6043,8 @@
 }
 # define VUINT32x8_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x8_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint32x8 vuint32x8_cmpgt(vuint32x8 vec1, vuint32x8 vec2)
 {
@@ -5441,6 +6053,8 @@
 }
 # define VUINT32x8_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x8_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint32x8 vuint32x8_cmple(vuint32x8 vec1, vuint32x8 vec2)
 {
@@ -5449,6 +6063,8 @@
 }
 # define VUINT32x8_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x8_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint32x8 vuint32x8_cmpge(vuint32x8 vec1, vuint32x8 vec2)
 {
@@ -5457,6 +6073,8 @@
 }
 # define VUINT32x8_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x8_MIN_DEFINED
 VEC_FUNC_IMPL vuint32x8 vuint32x8_min(vuint32x8 vec1, vuint32x8 vec2)
 {
@@ -5467,6 +6085,8 @@
 }
 # define VUINT32x8_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x8_MAX_DEFINED
 VEC_FUNC_IMPL vuint32x8 vuint32x8_max(vuint32x8 vec1, vuint32x8 vec2)
 {
@@ -5477,14 +6097,19 @@
 }
 # define VUINT32x8_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x8_AVG_DEFINED
 VEC_FUNC_IMPL vuint32x8 vuint32x8_avg(vuint32x8 vec1, vuint32x8 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint32x8 ones = vint32x8_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT32x8_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x8_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint32x8 vuint32x8_lshift(vuint32x8 vec1, vuint32x8 vec2)
 {
@@ -5493,6 +6118,8 @@
 }
 # define VUINT32x8_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x8_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint32x8 vuint32x8_rshift(vuint32x8 vec1, vuint32x8 vec2)
 {
@@ -5501,6 +6128,8 @@
 }
 # define VUINT32x8_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x8_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint32x8 vuint32x8_lrshift(vuint32x8 vec1, vuint32x8 vec2)
 {
@@ -5509,6 +6138,7 @@
 }
 # define VUINT32x8_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT32x8_NOT_DEFINED
 VEC_FUNC_IMPL vuint32x8 vuint32x8_not(vuint32x8 vec)
 {
@@ -5610,6 +6240,7 @@
 }
 # define VINT32x16_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x16_CMPLT_DEFINED
 VEC_FUNC_IMPL vint32x16 vint32x16_cmplt(vint32x16 vec1, vint32x16 vec2)
 {
@@ -5618,6 +6249,8 @@
 }
 # define VINT32x16_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x16_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint32x16 vint32x16_cmpeq(vint32x16 vec1, vint32x16 vec2)
 {
@@ -5626,6 +6259,8 @@
 }
 # define VINT32x16_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x16_CMPGT_DEFINED
 VEC_FUNC_IMPL vint32x16 vint32x16_cmpgt(vint32x16 vec1, vint32x16 vec2)
 {
@@ -5634,6 +6269,8 @@
 }
 # define VINT32x16_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x16_CMPLE_DEFINED
 VEC_FUNC_IMPL vint32x16 vint32x16_cmple(vint32x16 vec1, vint32x16 vec2)
 {
@@ -5642,6 +6279,8 @@
 }
 # define VINT32x16_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x16_CMPGE_DEFINED
 VEC_FUNC_IMPL vint32x16 vint32x16_cmpge(vint32x16 vec1, vint32x16 vec2)
 {
@@ -5650,6 +6289,8 @@
 }
 # define VINT32x16_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x16_MIN_DEFINED
 VEC_FUNC_IMPL vint32x16 vint32x16_min(vint32x16 vec1, vint32x16 vec2)
 {
@@ -5660,6 +6301,8 @@
 }
 # define VINT32x16_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x16_MAX_DEFINED
 VEC_FUNC_IMPL vint32x16 vint32x16_max(vint32x16 vec1, vint32x16 vec2)
 {
@@ -5670,6 +6313,8 @@
 }
 # define VINT32x16_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x16_AVG_DEFINED
 VEC_FUNC_IMPL vint32x16 vint32x16_avg(vint32x16 vec1, vint32x16 vec2)
 {
@@ -5684,6 +6329,8 @@
 }
 # define VINT32x16_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x16_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint32x16 vint32x16_lshift(vint32x16 vec1, vuint32x16 vec2)
 {
@@ -5692,6 +6339,8 @@
 }
 # define VINT32x16_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x16_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint32x16 vint32x16_rshift(vint32x16 vec1, vuint32x16 vec2)
 {
@@ -5700,6 +6349,8 @@
 }
 # define VINT32x16_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT32x16_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint32x16 vint32x16_lrshift(vint32x16 vec1, vuint32x16 vec2)
 {
@@ -5708,6 +6359,7 @@
 }
 # define VINT32x16_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT32x16_NOT_DEFINED
 VEC_FUNC_IMPL vint32x16 vint32x16_not(vint32x16 vec)
 {
@@ -5809,6 +6461,7 @@
 }
 # define VUINT32x16_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x16_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint32x16 vuint32x16_cmplt(vuint32x16 vec1, vuint32x16 vec2)
 {
@@ -5817,6 +6470,8 @@
 }
 # define VUINT32x16_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x16_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint32x16 vuint32x16_cmpeq(vuint32x16 vec1, vuint32x16 vec2)
 {
@@ -5825,6 +6480,8 @@
 }
 # define VUINT32x16_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x16_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint32x16 vuint32x16_cmpgt(vuint32x16 vec1, vuint32x16 vec2)
 {
@@ -5833,6 +6490,8 @@
 }
 # define VUINT32x16_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x16_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint32x16 vuint32x16_cmple(vuint32x16 vec1, vuint32x16 vec2)
 {
@@ -5841,6 +6500,8 @@
 }
 # define VUINT32x16_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x16_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint32x16 vuint32x16_cmpge(vuint32x16 vec1, vuint32x16 vec2)
 {
@@ -5849,6 +6510,8 @@
 }
 # define VUINT32x16_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x16_MIN_DEFINED
 VEC_FUNC_IMPL vuint32x16 vuint32x16_min(vuint32x16 vec1, vuint32x16 vec2)
 {
@@ -5859,6 +6522,8 @@
 }
 # define VUINT32x16_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x16_MAX_DEFINED
 VEC_FUNC_IMPL vuint32x16 vuint32x16_max(vuint32x16 vec1, vuint32x16 vec2)
 {
@@ -5869,14 +6534,19 @@
 }
 # define VUINT32x16_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x16_AVG_DEFINED
 VEC_FUNC_IMPL vuint32x16 vuint32x16_avg(vuint32x16 vec1, vuint32x16 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint32x16 ones = vint32x16_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT32x16_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x16_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint32x16 vuint32x16_lshift(vuint32x16 vec1, vuint32x16 vec2)
 {
@@ -5885,6 +6555,8 @@
 }
 # define VUINT32x16_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x16_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint32x16 vuint32x16_rshift(vuint32x16 vec1, vuint32x16 vec2)
 {
@@ -5893,6 +6565,8 @@
 }
 # define VUINT32x16_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT32x16_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint32x16 vuint32x16_lrshift(vuint32x16 vec1, vuint32x16 vec2)
 {
@@ -5901,6 +6575,7 @@
 }
 # define VUINT32x16_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT32x16_NOT_DEFINED
 VEC_FUNC_IMPL vuint32x16 vuint32x16_not(vuint32x16 vec)
 {
@@ -6002,6 +6677,7 @@
 }
 # define VINT64x2_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x2_CMPLT_DEFINED
 VEC_FUNC_IMPL vint64x2 vint64x2_cmplt(vint64x2 vec1, vint64x2 vec2)
 {
@@ -6010,6 +6686,8 @@
 }
 # define VINT64x2_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x2_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint64x2 vint64x2_cmpeq(vint64x2 vec1, vint64x2 vec2)
 {
@@ -6018,6 +6696,8 @@
 }
 # define VINT64x2_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x2_CMPGT_DEFINED
 VEC_FUNC_IMPL vint64x2 vint64x2_cmpgt(vint64x2 vec1, vint64x2 vec2)
 {
@@ -6026,6 +6706,8 @@
 }
 # define VINT64x2_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x2_CMPLE_DEFINED
 VEC_FUNC_IMPL vint64x2 vint64x2_cmple(vint64x2 vec1, vint64x2 vec2)
 {
@@ -6034,6 +6716,8 @@
 }
 # define VINT64x2_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x2_CMPGE_DEFINED
 VEC_FUNC_IMPL vint64x2 vint64x2_cmpge(vint64x2 vec1, vint64x2 vec2)
 {
@@ -6042,6 +6726,8 @@
 }
 # define VINT64x2_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x2_MIN_DEFINED
 VEC_FUNC_IMPL vint64x2 vint64x2_min(vint64x2 vec1, vint64x2 vec2)
 {
@@ -6052,6 +6738,8 @@
 }
 # define VINT64x2_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x2_MAX_DEFINED
 VEC_FUNC_IMPL vint64x2 vint64x2_max(vint64x2 vec1, vint64x2 vec2)
 {
@@ -6062,6 +6750,8 @@
 }
 # define VINT64x2_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x2_AVG_DEFINED
 VEC_FUNC_IMPL vint64x2 vint64x2_avg(vint64x2 vec1, vint64x2 vec2)
 {
@@ -6076,6 +6766,8 @@
 }
 # define VINT64x2_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x2_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint64x2 vint64x2_lshift(vint64x2 vec1, vuint64x2 vec2)
 {
@@ -6084,6 +6776,8 @@
 }
 # define VINT64x2_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x2_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint64x2 vint64x2_rshift(vint64x2 vec1, vuint64x2 vec2)
 {
@@ -6092,6 +6786,8 @@
 }
 # define VINT64x2_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x2_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint64x2 vint64x2_lrshift(vint64x2 vec1, vuint64x2 vec2)
 {
@@ -6100,6 +6796,7 @@
 }
 # define VINT64x2_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT64x2_NOT_DEFINED
 VEC_FUNC_IMPL vint64x2 vint64x2_not(vint64x2 vec)
 {
@@ -6201,6 +6898,7 @@
 }
 # define VUINT64x2_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x2_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint64x2 vuint64x2_cmplt(vuint64x2 vec1, vuint64x2 vec2)
 {
@@ -6209,6 +6907,8 @@
 }
 # define VUINT64x2_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x2_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint64x2 vuint64x2_cmpeq(vuint64x2 vec1, vuint64x2 vec2)
 {
@@ -6217,6 +6917,8 @@
 }
 # define VUINT64x2_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x2_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint64x2 vuint64x2_cmpgt(vuint64x2 vec1, vuint64x2 vec2)
 {
@@ -6225,6 +6927,8 @@
 }
 # define VUINT64x2_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x2_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint64x2 vuint64x2_cmple(vuint64x2 vec1, vuint64x2 vec2)
 {
@@ -6233,6 +6937,8 @@
 }
 # define VUINT64x2_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x2_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint64x2 vuint64x2_cmpge(vuint64x2 vec1, vuint64x2 vec2)
 {
@@ -6241,6 +6947,8 @@
 }
 # define VUINT64x2_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x2_MIN_DEFINED
 VEC_FUNC_IMPL vuint64x2 vuint64x2_min(vuint64x2 vec1, vuint64x2 vec2)
 {
@@ -6251,6 +6959,8 @@
 }
 # define VUINT64x2_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x2_MAX_DEFINED
 VEC_FUNC_IMPL vuint64x2 vuint64x2_max(vuint64x2 vec1, vuint64x2 vec2)
 {
@@ -6261,14 +6971,19 @@
 }
 # define VUINT64x2_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x2_AVG_DEFINED
 VEC_FUNC_IMPL vuint64x2 vuint64x2_avg(vuint64x2 vec1, vuint64x2 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint64x2 ones = vint64x2_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT64x2_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x2_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint64x2 vuint64x2_lshift(vuint64x2 vec1, vuint64x2 vec2)
 {
@@ -6277,6 +6992,8 @@
 }
 # define VUINT64x2_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x2_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint64x2 vuint64x2_rshift(vuint64x2 vec1, vuint64x2 vec2)
 {
@@ -6285,6 +7002,8 @@
 }
 # define VUINT64x2_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x2_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint64x2 vuint64x2_lrshift(vuint64x2 vec1, vuint64x2 vec2)
 {
@@ -6293,6 +7012,7 @@
 }
 # define VUINT64x2_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT64x2_NOT_DEFINED
 VEC_FUNC_IMPL vuint64x2 vuint64x2_not(vuint64x2 vec)
 {
@@ -6394,6 +7114,7 @@
 }
 # define VINT64x4_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x4_CMPLT_DEFINED
 VEC_FUNC_IMPL vint64x4 vint64x4_cmplt(vint64x4 vec1, vint64x4 vec2)
 {
@@ -6402,6 +7123,8 @@
 }
 # define VINT64x4_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x4_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint64x4 vint64x4_cmpeq(vint64x4 vec1, vint64x4 vec2)
 {
@@ -6410,6 +7133,8 @@
 }
 # define VINT64x4_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x4_CMPGT_DEFINED
 VEC_FUNC_IMPL vint64x4 vint64x4_cmpgt(vint64x4 vec1, vint64x4 vec2)
 {
@@ -6418,6 +7143,8 @@
 }
 # define VINT64x4_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x4_CMPLE_DEFINED
 VEC_FUNC_IMPL vint64x4 vint64x4_cmple(vint64x4 vec1, vint64x4 vec2)
 {
@@ -6426,6 +7153,8 @@
 }
 # define VINT64x4_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x4_CMPGE_DEFINED
 VEC_FUNC_IMPL vint64x4 vint64x4_cmpge(vint64x4 vec1, vint64x4 vec2)
 {
@@ -6434,6 +7163,8 @@
 }
 # define VINT64x4_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x4_MIN_DEFINED
 VEC_FUNC_IMPL vint64x4 vint64x4_min(vint64x4 vec1, vint64x4 vec2)
 {
@@ -6444,6 +7175,8 @@
 }
 # define VINT64x4_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x4_MAX_DEFINED
 VEC_FUNC_IMPL vint64x4 vint64x4_max(vint64x4 vec1, vint64x4 vec2)
 {
@@ -6454,6 +7187,8 @@
 }
 # define VINT64x4_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x4_AVG_DEFINED
 VEC_FUNC_IMPL vint64x4 vint64x4_avg(vint64x4 vec1, vint64x4 vec2)
 {
@@ -6468,6 +7203,8 @@
 }
 # define VINT64x4_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x4_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint64x4 vint64x4_lshift(vint64x4 vec1, vuint64x4 vec2)
 {
@@ -6476,6 +7213,8 @@
 }
 # define VINT64x4_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x4_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint64x4 vint64x4_rshift(vint64x4 vec1, vuint64x4 vec2)
 {
@@ -6484,6 +7223,8 @@
 }
 # define VINT64x4_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x4_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint64x4 vint64x4_lrshift(vint64x4 vec1, vuint64x4 vec2)
 {
@@ -6492,6 +7233,7 @@
 }
 # define VINT64x4_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT64x4_NOT_DEFINED
 VEC_FUNC_IMPL vint64x4 vint64x4_not(vint64x4 vec)
 {
@@ -6593,6 +7335,7 @@
 }
 # define VUINT64x4_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x4_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint64x4 vuint64x4_cmplt(vuint64x4 vec1, vuint64x4 vec2)
 {
@@ -6601,6 +7344,8 @@
 }
 # define VUINT64x4_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x4_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint64x4 vuint64x4_cmpeq(vuint64x4 vec1, vuint64x4 vec2)
 {
@@ -6609,6 +7354,8 @@
 }
 # define VUINT64x4_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x4_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint64x4 vuint64x4_cmpgt(vuint64x4 vec1, vuint64x4 vec2)
 {
@@ -6617,6 +7364,8 @@
 }
 # define VUINT64x4_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x4_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint64x4 vuint64x4_cmple(vuint64x4 vec1, vuint64x4 vec2)
 {
@@ -6625,6 +7374,8 @@
 }
 # define VUINT64x4_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x4_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint64x4 vuint64x4_cmpge(vuint64x4 vec1, vuint64x4 vec2)
 {
@@ -6633,6 +7384,8 @@
 }
 # define VUINT64x4_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x4_MIN_DEFINED
 VEC_FUNC_IMPL vuint64x4 vuint64x4_min(vuint64x4 vec1, vuint64x4 vec2)
 {
@@ -6643,6 +7396,8 @@
 }
 # define VUINT64x4_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x4_MAX_DEFINED
 VEC_FUNC_IMPL vuint64x4 vuint64x4_max(vuint64x4 vec1, vuint64x4 vec2)
 {
@@ -6653,14 +7408,19 @@
 }
 # define VUINT64x4_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x4_AVG_DEFINED
 VEC_FUNC_IMPL vuint64x4 vuint64x4_avg(vuint64x4 vec1, vuint64x4 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint64x4 ones = vint64x4_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT64x4_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x4_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint64x4 vuint64x4_lshift(vuint64x4 vec1, vuint64x4 vec2)
 {
@@ -6669,6 +7429,8 @@
 }
 # define VUINT64x4_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x4_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint64x4 vuint64x4_rshift(vuint64x4 vec1, vuint64x4 vec2)
 {
@@ -6677,6 +7439,8 @@
 }
 # define VUINT64x4_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x4_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint64x4 vuint64x4_lrshift(vuint64x4 vec1, vuint64x4 vec2)
 {
@@ -6685,6 +7449,7 @@
 }
 # define VUINT64x4_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT64x4_NOT_DEFINED
 VEC_FUNC_IMPL vuint64x4 vuint64x4_not(vuint64x4 vec)
 {
@@ -6786,6 +7551,7 @@
 }
 # define VINT64x8_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x8_CMPLT_DEFINED
 VEC_FUNC_IMPL vint64x8 vint64x8_cmplt(vint64x8 vec1, vint64x8 vec2)
 {
@@ -6794,6 +7560,8 @@
 }
 # define VINT64x8_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x8_CMPEQ_DEFINED
 VEC_FUNC_IMPL vint64x8 vint64x8_cmpeq(vint64x8 vec1, vint64x8 vec2)
 {
@@ -6802,6 +7570,8 @@
 }
 # define VINT64x8_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x8_CMPGT_DEFINED
 VEC_FUNC_IMPL vint64x8 vint64x8_cmpgt(vint64x8 vec1, vint64x8 vec2)
 {
@@ -6810,6 +7580,8 @@
 }
 # define VINT64x8_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x8_CMPLE_DEFINED
 VEC_FUNC_IMPL vint64x8 vint64x8_cmple(vint64x8 vec1, vint64x8 vec2)
 {
@@ -6818,6 +7590,8 @@
 }
 # define VINT64x8_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x8_CMPGE_DEFINED
 VEC_FUNC_IMPL vint64x8 vint64x8_cmpge(vint64x8 vec1, vint64x8 vec2)
 {
@@ -6826,6 +7600,8 @@
 }
 # define VINT64x8_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x8_MIN_DEFINED
 VEC_FUNC_IMPL vint64x8 vint64x8_min(vint64x8 vec1, vint64x8 vec2)
 {
@@ -6836,6 +7612,8 @@
 }
 # define VINT64x8_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x8_MAX_DEFINED
 VEC_FUNC_IMPL vint64x8 vint64x8_max(vint64x8 vec1, vint64x8 vec2)
 {
@@ -6846,6 +7624,8 @@
 }
 # define VINT64x8_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x8_AVG_DEFINED
 VEC_FUNC_IMPL vint64x8 vint64x8_avg(vint64x8 vec1, vint64x8 vec2)
 {
@@ -6860,6 +7640,8 @@
 }
 # define VINT64x8_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x8_LSHIFT_DEFINED
 VEC_FUNC_IMPL vint64x8 vint64x8_lshift(vint64x8 vec1, vuint64x8 vec2)
 {
@@ -6868,6 +7650,8 @@
 }
 # define VINT64x8_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x8_RSHIFT_DEFINED
 VEC_FUNC_IMPL vint64x8 vint64x8_rshift(vint64x8 vec1, vuint64x8 vec2)
 {
@@ -6876,6 +7660,8 @@
 }
 # define VINT64x8_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VINT64x8_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vint64x8 vint64x8_lrshift(vint64x8 vec1, vuint64x8 vec2)
 {
@@ -6884,6 +7670,7 @@
 }
 # define VINT64x8_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VINT64x8_NOT_DEFINED
 VEC_FUNC_IMPL vint64x8 vint64x8_not(vint64x8 vec)
 {
@@ -6985,6 +7772,7 @@
 }
 # define VUINT64x8_XOR_DEFINED
 #endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x8_CMPLT_DEFINED
 VEC_FUNC_IMPL vuint64x8 vuint64x8_cmplt(vuint64x8 vec1, vuint64x8 vec2)
 {
@@ -6993,6 +7781,8 @@
 }
 # define VUINT64x8_CMPLT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x8_CMPEQ_DEFINED
 VEC_FUNC_IMPL vuint64x8 vuint64x8_cmpeq(vuint64x8 vec1, vuint64x8 vec2)
 {
@@ -7001,6 +7791,8 @@
 }
 # define VUINT64x8_CMPEQ_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x8_CMPGT_DEFINED
 VEC_FUNC_IMPL vuint64x8 vuint64x8_cmpgt(vuint64x8 vec1, vuint64x8 vec2)
 {
@@ -7009,6 +7801,8 @@
 }
 # define VUINT64x8_CMPGT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x8_CMPLE_DEFINED
 VEC_FUNC_IMPL vuint64x8 vuint64x8_cmple(vuint64x8 vec1, vuint64x8 vec2)
 {
@@ -7017,6 +7811,8 @@
 }
 # define VUINT64x8_CMPLE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x8_CMPGE_DEFINED
 VEC_FUNC_IMPL vuint64x8 vuint64x8_cmpge(vuint64x8 vec1, vuint64x8 vec2)
 {
@@ -7025,6 +7821,8 @@
 }
 # define VUINT64x8_CMPGE_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x8_MIN_DEFINED
 VEC_FUNC_IMPL vuint64x8 vuint64x8_min(vuint64x8 vec1, vuint64x8 vec2)
 {
@@ -7035,6 +7833,8 @@
 }
 # define VUINT64x8_MIN_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x8_MAX_DEFINED
 VEC_FUNC_IMPL vuint64x8 vuint64x8_max(vuint64x8 vec1, vuint64x8 vec2)
 {
@@ -7045,14 +7845,19 @@
 }
 # define VUINT64x8_MAX_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x8_AVG_DEFINED
 VEC_FUNC_IMPL vuint64x8 vuint64x8_avg(vuint64x8 vec1, vuint64x8 vec2)
 {
-	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);
+	vint64x8 ones = vint64x8_splat(1);
+	vec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);
 	return vec1;
 }
 # define VUINT64x8_AVG_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x8_LSHIFT_DEFINED
 VEC_FUNC_IMPL vuint64x8 vuint64x8_lshift(vuint64x8 vec1, vuint64x8 vec2)
 {
@@ -7061,6 +7866,8 @@
 }
 # define VUINT64x8_LSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x8_RSHIFT_DEFINED
 VEC_FUNC_IMPL vuint64x8 vuint64x8_rshift(vuint64x8 vec1, vuint64x8 vec2)
 {
@@ -7069,6 +7876,8 @@
 }
 # define VUINT64x8_RSHIFT_DEFINED
 #endif
+#endif
+#if VEC_GNUC_ATLEAST(4, 3, 0)
 #ifndef VUINT64x8_LRSHIFT_DEFINED
 VEC_FUNC_IMPL vuint64x8 vuint64x8_lrshift(vuint64x8 vec1, vuint64x8 vec2)
 {
@@ -7077,6 +7886,7 @@
 }
 # define VUINT64x8_LRSHIFT_DEFINED
 #endif
+#endif
 #ifndef VUINT64x8_NOT_DEFINED
 VEC_FUNC_IMPL vuint64x8 vuint64x8_not(vuint64x8 vec)
 {
diff -r 55cadb1fac4b -r c6e0df09b86f include/vec/impl/generic.h
--- a/include/vec/impl/generic.h	Sun Apr 27 02:49:53 2025 -0400
+++ b/include/vec/impl/generic.h	Mon Apr 28 16:31:59 2025 -0400
@@ -109,7 +109,7 @@
 	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_avg(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \
 	{ \
 		for (int i = 0; i < size; i++) \
-			vec1.generic[i] = vec_##sign##avg(vec1.generic[i], vec2.generic[i]); \
+			vec1.generic[i] = vec_im##sign##avg(vec1.generic[i], vec2.generic[i]); \
 	\
 		return vec1; \
 	}
@@ -208,79 +208,6 @@
 		return v##sign##int##bits##x##size##_or(a, b); \
 	}
 
-#define VEC_GENERIC_DBL_SPLAT(sign, bits, size, halfsize) \
-	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_splat(vec_##sign##int##bits x) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-	\
-		vec.generic[0] = v##sign##int##bits##x##halfsize##_splat(x); \
-		vec.generic[1] = v##sign##int##bits##x##halfsize##_splat(x); \
-	\
-		return vec; \
-	}
-
-#define VEC_GENERIC_DBL_LOAD_EX(name, sign, bits, size, halfsize) \
-	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_##name(const vec_##sign##int##bits x[size]) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-	\
-		vec.generic[0] = v##sign##int##bits##x##halfsize##_##name(x); \
-		vec.generic[1] = v##sign##int##bits##x##halfsize##_##name(x + halfsize); \
-	\
-		return vec; \
-	}
-
-#define VEC_GENERIC_DBL_LOAD(sign, bits, size, halfsize) VEC_GENERIC_DBL_LOAD_EX(load, sign, bits, size, halfsize)
-#define VEC_GENERIC_DBL_LOAD_ALIGNED(sign, bits, size, halfsize) VEC_GENERIC_DBL_LOAD_EX(load_aligned, sign, bits, size, halfsize)
-
-#define VEC_GENERIC_DBL_STORE_EX(name, sign, bits, size, halfsize) \
-	VEC_FUNC_IMPL void v##sign##int##bits##x##size##_##name(v##sign##int##bits##x##size vec, vec_##sign##int##bits x[size]) \
-	{ \
-		v##sign##int##bits##x##halfsize##_##name(vec.generic[0], x); \
-		v##sign##int##bits##x##halfsize##_##name(vec.generic[1], x + halfsize); \
-	}
-
-#define VEC_GENERIC_DBL_STORE(sign, bits, size, halfsize) VEC_GENERIC_DBL_STORE_EX(store, sign, bits, size, halfsize)
-#define VEC_GENERIC_DBL_STORE_ALIGNED(sign, bits, size, halfsize) VEC_GENERIC_DBL_STORE_EX(store_aligned, sign, bits, size, halfsize)
-
-#define VEC_GENERIC_DBL_OP(name, sign, bits, size, halfsize, secondsign) \
-	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_##name(v##sign##int##bits##x##size vec1, v##secondsign##int##bits##x##size vec2) \
-	{ \
-		vec1.generic[0] = v##sign##int##bits##x##halfsize##_##name(vec1.generic[0], vec2.generic[0]); \
-		vec1.generic[1] = v##sign##int##bits##x##halfsize##_##name(vec1.generic[1], vec2.generic[1]); \
-	\
-		return vec1; \
-	}
-
-#define VEC_GENERIC_DBL_ADD(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(add, sign, bits, size, halfsize, sign)
-#define VEC_GENERIC_DBL_SUB(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(sub, sign, bits, size, halfsize, sign)
-#define VEC_GENERIC_DBL_MUL(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(mul, sign, bits, size, halfsize, sign)
-#define VEC_GENERIC_DBL_DIV(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(div, sign, bits, size, halfsize, sign)
-#define VEC_GENERIC_DBL_MOD(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(mod, sign, bits, size, halfsize, sign)
-#define VEC_GENERIC_DBL_AVG(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(avg, sign, bits, size, halfsize, sign)
-#define VEC_GENERIC_DBL_LSHIFT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(lshift, sign, bits, size, halfsize, u)
-#define VEC_GENERIC_DBL_RSHIFT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(rshift, sign, bits, size, halfsize, u)
-#define VEC_GENERIC_DBL_LRSHIFT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(lrshift, sign, bits, size, halfsize, u)
-#define VEC_GENERIC_DBL_AND(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(and, sign, bits, size, halfsize, sign)
-#define VEC_GENERIC_DBL_OR(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(or, sign, bits, size, halfsize, sign)
-#define VEC_GENERIC_DBL_XOR(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(xor, sign, bits, size, halfsize, sign)
-#define VEC_GENERIC_DBL_MIN(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(min, sign, bits, size, halfsize, sign)
-#define VEC_GENERIC_DBL_MAX(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(max, sign, bits, size, halfsize, sign)
-#define VEC_GENERIC_DBL_CMPLT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmplt, sign, bits, size, halfsize, sign)
-#define VEC_GENERIC_DBL_CMPLE(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmple, sign, bits, size, halfsize, sign)
-#define VEC_GENERIC_DBL_CMPEQ(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmpeq, sign, bits, size, halfsize, sign)
-#define VEC_GENERIC_DBL_CMPGE(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmpge, sign, bits, size, halfsize, sign)
-#define VEC_GENERIC_DBL_CMPGT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmpgt, sign, bits, size, halfsize, sign)
-
-#define VEC_GENERIC_DBL_NOT(sign, bits, size, halfsize) \
-	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_not(v##sign##int##bits##x##size vec) \
-	{ \
-		vec.generic[0] = v##sign##int##bits##x##halfsize##_not(vec.generic[0]); \
-		vec.generic[1] = v##sign##int##bits##x##halfsize##_not(vec.generic[1]); \
-	\
-		return vec; \
-	}
-
 /* ------------------------------------------------------------------------ */
 /* PREPROCESSOR HELL INCOMING */
 
@@ -494,1296 +421,6 @@
 #endif
 
 
-/* vuint8x4 */
-
-#ifndef VINT8x4_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(/* nothing */, 8, 4, 2)
-# define VINT8x4_SPLAT_DEFINED
-#endif
-
-#ifndef VINT8x4_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 8, 4, 2)
-# define VINT8x4_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT8x4_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(/* nothing */, 8, 4, 2)
-# define VINT8x4_LOAD_DEFINED
-#endif
-
-#ifndef VINT8x4_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 8, 4, 2)
-# define VINT8x4_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT8x4_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(/* nothing */, 8, 4, 2)
-# define VINT8x4_STORE_DEFINED
-#endif
-
-#ifndef VINT8x4_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(/* nothing */, 8, 4, 2)
-# define VINT8x4_ADD_DEFINED
-#endif
-
-#ifndef VINT8x4_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(/* nothing */, 8, 4, 2)
-# define VINT8x4_SUB_DEFINED
-#endif
-
-#ifndef VINT8x4_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(/* nothing */, 8, 4, 2)
-# define VINT8x4_MUL_DEFINED
-#endif
-
-#ifndef VINT8x4_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(/* nothing */, 8, 4, 2)
-# define VINT8x4_DIV_DEFINED
-#endif
-
-#ifndef VINT8x4_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(/* nothing */, 8, 4, 2)
-# define VINT8x4_MOD_DEFINED
-#endif
-
-#ifndef VINT8x4_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(/* nothing */, 8, 4, 2)
-# define VINT8x4_AVG_DEFINED
-#endif
-
-#ifndef VINT8x4_AND_DEFINED
-VEC_GENERIC_DBL_AND(/* nothing */, 8, 4, 2)
-# define VINT8x4_AND_DEFINED
-#endif
-
-#ifndef VINT8x4_OR_DEFINED
-VEC_GENERIC_DBL_OR(/* nothing */, 8, 4, 2)
-# define VINT8x4_OR_DEFINED
-#endif
-
-#ifndef VINT8x4_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(/* nothing */, 8, 4, 2)
-# define VINT8x4_XOR_DEFINED
-#endif
-
-#ifndef VINT8x4_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(/* nothing */, 8, 4, 2)
-# define VINT8x4_NOT_DEFINED
-#endif
-
-#ifndef VINT8x4_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(/* nothing */, 8, 4, 2)
-# define VINT8x4_CMPLT_DEFINED
-#endif
-
-#ifndef VINT8x4_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(/* nothing */, 8, 4, 2)
-# define VINT8x4_CMPEQ_DEFINED
-#endif
-
-#ifndef VINT8x4_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(/* nothing */, 8, 4, 2)
-# define VINT8x4_CMPGT_DEFINED
-#endif
-
-#ifndef VINT8x4_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(/* nothing */, 8, 4, 2)
-# define VINT8x4_CMPLE_DEFINED
-#endif
-
-#ifndef VINT8x4_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(/* nothing */, 8, 4, 2)
-# define VINT8x4_CMPGE_DEFINED
-#endif
-
-#ifndef VINT8x4_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(/* nothing */, 8, 4, 2)
-# define VINT8x4_MIN_DEFINED
-#endif
-
-#ifndef VINT8x4_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(/* nothing */, 8, 4, 2)
-# define VINT8x4_MAX_DEFINED
-#endif
-
-#ifndef VINT8x4_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(/* nothing */, 8, 4, 2)
-# define VINT8x4_RSHIFT_DEFINED
-#endif
-
-#ifndef VINT8x4_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 8, 4, 2)
-# define VINT8x4_LRSHIFT_DEFINED
-#endif
-
-#ifndef VINT8x4_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(/* nothing */, 8, 4, 2)
-# define VINT8x4_LSHIFT_DEFINED
-#endif
-
-
-
-/* vint8x4 */
-
-#ifndef VUINT8x4_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(u, 8, 4, 2)
-# define VUINT8x4_SPLAT_DEFINED
-#endif
-
-#ifndef VUINT8x4_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(u, 8, 4, 2)
-# define VUINT8x4_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT8x4_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(u, 8, 4, 2)
-# define VUINT8x4_LOAD_DEFINED
-#endif
-
-#ifndef VUINT8x4_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(u, 8, 4, 2)
-# define VUINT8x4_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT8x4_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(u, 8, 4, 2)
-# define VUINT8x4_STORE_DEFINED
-#endif
-
-#ifndef VUINT8x4_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(u, 8, 4, 2)
-# define VUINT8x4_ADD_DEFINED
-#endif
-
-#ifndef VUINT8x4_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(u, 8, 4, 2)
-# define VUINT8x4_SUB_DEFINED
-#endif
-
-#ifndef VUINT8x4_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(u, 8, 4, 2)
-# define VUINT8x4_MUL_DEFINED
-#endif
-
-#ifndef VUINT8x4_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(u, 8, 4, 2)
-# define VUINT8x4_DIV_DEFINED
-#endif
-
-#ifndef VUINT8x4_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(u, 8, 4, 2)
-# define VUINT8x4_MOD_DEFINED
-#endif
-
-#ifndef VUINT8x4_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(u, 8, 4, 2)
-# define VUINT8x4_AVG_DEFINED
-#endif
-
-#ifndef VUINT8x4_AND_DEFINED
-VEC_GENERIC_DBL_AND(u, 8, 4, 2)
-# define VUINT8x4_AND_DEFINED
-#endif
-
-#ifndef VUINT8x4_OR_DEFINED
-VEC_GENERIC_DBL_OR(u, 8, 4, 2)
-# define VUINT8x4_OR_DEFINED
-#endif
-
-#ifndef VUINT8x4_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(u, 8, 4, 2)
-# define VUINT8x4_XOR_DEFINED
-#endif
-
-#ifndef VUINT8x4_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(u, 8, 4, 2)
-# define VUINT8x4_NOT_DEFINED
-#endif
-
-#ifndef VUINT8x4_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(u, 8, 4, 2)
-# define VUINT8x4_CMPLT_DEFINED
-#endif
-
-#ifndef VUINT8x4_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(u, 8, 4, 2)
-# define VUINT8x4_CMPEQ_DEFINED
-#endif
-
-#ifndef VUINT8x4_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(u, 8, 4, 2)
-# define VUINT8x4_CMPGT_DEFINED
-#endif
-
-#ifndef VUINT8x4_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(u, 8, 4, 2)
-# define VUINT8x4_CMPLE_DEFINED
-#endif
-
-#ifndef VUINT8x4_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(u, 8, 4, 2)
-# define VUINT8x4_CMPGE_DEFINED
-#endif
-
-#ifndef VUINT8x4_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(u, 8, 4, 2)
-# define VUINT8x4_MIN_DEFINED
-#endif
-
-#ifndef VUINT8x4_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(u, 8, 4, 2)
-# define VUINT8x4_MAX_DEFINED
-#endif
-
-#ifndef VUINT8x4_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(u, 8, 4, 2)
-# define VUINT8x4_RSHIFT_DEFINED
-#endif
-
-#ifndef VUINT8x4_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(u, 8, 4, 2)
-# define VUINT8x4_LRSHIFT_DEFINED
-#endif
-
-#ifndef VUINT8x4_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(u, 8, 4, 2)
-# define VUINT8x4_LSHIFT_DEFINED
-#endif
-
-
-
-/* vuint8x8 */
-
-#ifndef VINT8x8_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(/* nothing */, 8, 8, 4)
-# define VINT8x8_SPLAT_DEFINED
-#endif
-
-#ifndef VINT8x8_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 8, 8, 4)
-# define VINT8x8_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT8x8_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(/* nothing */, 8, 8, 4)
-# define VINT8x8_LOAD_DEFINED
-#endif
-
-#ifndef VINT8x8_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 8, 8, 4)
-# define VINT8x8_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT8x8_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(/* nothing */, 8, 8, 4)
-# define VINT8x8_STORE_DEFINED
-#endif
-
-#ifndef VINT8x8_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(/* nothing */, 8, 8, 4)
-# define VINT8x8_ADD_DEFINED
-#endif
-
-#ifndef VINT8x8_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(/* nothing */, 8, 8, 4)
-# define VINT8x8_SUB_DEFINED
-#endif
-
-#ifndef VINT8x8_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(/* nothing */, 8, 8, 4)
-# define VINT8x8_MUL_DEFINED
-#endif
-
-#ifndef VINT8x8_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(/* nothing */, 8, 8, 4)
-# define VINT8x8_DIV_DEFINED
-#endif
-
-#ifndef VINT8x8_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(/* nothing */, 8, 8, 4)
-# define VINT8x8_MOD_DEFINED
-#endif
-
-#ifndef VINT8x8_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(/* nothing */, 8, 8, 4)
-# define VINT8x8_AVG_DEFINED
-#endif
-
-#ifndef VINT8x8_AND_DEFINED
-VEC_GENERIC_DBL_AND(/* nothing */, 8, 8, 4)
-# define VINT8x8_AND_DEFINED
-#endif
-
-#ifndef VINT8x8_OR_DEFINED
-VEC_GENERIC_DBL_OR(/* nothing */, 8, 8, 4)
-# define VINT8x8_OR_DEFINED
-#endif
-
-#ifndef VINT8x8_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(/* nothing */, 8, 8, 4)
-# define VINT8x8_XOR_DEFINED
-#endif
-
-#ifndef VINT8x8_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(/* nothing */, 8, 8, 4)
-# define VINT8x8_NOT_DEFINED
-#endif
-
-#ifndef VINT8x8_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(/* nothing */, 8, 8, 4)
-# define VINT8x8_CMPLT_DEFINED
-#endif
-
-#ifndef VINT8x8_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(/* nothing */, 8, 8, 4)
-# define VINT8x8_CMPEQ_DEFINED
-#endif
-
-#ifndef VINT8x8_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(/* nothing */, 8, 8, 4)
-# define VINT8x8_CMPGT_DEFINED
-#endif
-
-#ifndef VINT8x8_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(/* nothing */, 8, 8, 4)
-# define VINT8x8_CMPLE_DEFINED
-#endif
-
-#ifndef VINT8x8_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(/* nothing */, 8, 8, 4)
-# define VINT8x8_CMPGE_DEFINED
-#endif
-
-#ifndef VINT8x8_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(/* nothing */, 8, 8, 4)
-# define VINT8x8_MIN_DEFINED
-#endif
-
-#ifndef VINT8x8_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(/* nothing */, 8, 8, 4)
-# define VINT8x8_MAX_DEFINED
-#endif
-
-#ifndef VINT8x8_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(/* nothing */, 8, 8, 4)
-# define VINT8x8_RSHIFT_DEFINED
-#endif
-
-#ifndef VINT8x8_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 8, 8, 4)
-# define VINT8x8_LRSHIFT_DEFINED
-#endif
-
-#ifndef VINT8x8_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(/* nothing */, 8, 8, 4)
-# define VINT8x8_LSHIFT_DEFINED
-#endif
-
-
-
-/* vint8x8 */
-
-#ifndef VUINT8x8_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(u, 8, 8, 4)
-# define VUINT8x8_SPLAT_DEFINED
-#endif
-
-#ifndef VUINT8x8_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(u, 8, 8, 4)
-# define VUINT8x8_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT8x8_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(u, 8, 8, 4)
-# define VUINT8x8_LOAD_DEFINED
-#endif
-
-#ifndef VUINT8x8_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(u, 8, 8, 4)
-# define VUINT8x8_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT8x8_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(u, 8, 8, 4)
-# define VUINT8x8_STORE_DEFINED
-#endif
-
-#ifndef VUINT8x8_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(u, 8, 8, 4)
-# define VUINT8x8_ADD_DEFINED
-#endif
-
-#ifndef VUINT8x8_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(u, 8, 8, 4)
-# define VUINT8x8_SUB_DEFINED
-#endif
-
-#ifndef VUINT8x8_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(u, 8, 8, 4)
-# define VUINT8x8_MUL_DEFINED
-#endif
-
-#ifndef VUINT8x8_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(u, 8, 8, 4)
-# define VUINT8x8_DIV_DEFINED
-#endif
-
-#ifndef VUINT8x8_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(u, 8, 8, 4)
-# define VUINT8x8_MOD_DEFINED
-#endif
-
-#ifndef VUINT8x8_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(u, 8, 8, 4)
-# define VUINT8x8_AVG_DEFINED
-#endif
-
-#ifndef VUINT8x8_AND_DEFINED
-VEC_GENERIC_DBL_AND(u, 8, 8, 4)
-# define VUINT8x8_AND_DEFINED
-#endif
-
-#ifndef VUINT8x8_OR_DEFINED
-VEC_GENERIC_DBL_OR(u, 8, 8, 4)
-# define VUINT8x8_OR_DEFINED
-#endif
-
-#ifndef VUINT8x8_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(u, 8, 8, 4)
-# define VUINT8x8_XOR_DEFINED
-#endif
-
-#ifndef VUINT8x8_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(u, 8, 8, 4)
-# define VUINT8x8_NOT_DEFINED
-#endif
-
-#ifndef VUINT8x8_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(u, 8, 8, 4)
-# define VUINT8x8_CMPLT_DEFINED
-#endif
-
-#ifndef VUINT8x8_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(u, 8, 8, 4)
-# define VUINT8x8_CMPEQ_DEFINED
-#endif
-
-#ifndef VUINT8x8_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(u, 8, 8, 4)
-# define VUINT8x8_CMPGT_DEFINED
-#endif
-
-#ifndef VUINT8x8_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(u, 8, 8, 4)
-# define VUINT8x8_CMPLE_DEFINED
-#endif
-
-#ifndef VUINT8x8_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(u, 8, 8, 4)
-# define VUINT8x8_CMPGE_DEFINED
-#endif
-
-#ifndef VUINT8x8_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(u, 8, 8, 4)
-# define VUINT8x8_MIN_DEFINED
-#endif
-
-#ifndef VUINT8x8_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(u, 8, 8, 4)
-# define VUINT8x8_MAX_DEFINED
-#endif
-
-#ifndef VUINT8x8_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(u, 8, 8, 4)
-# define VUINT8x8_RSHIFT_DEFINED
-#endif
-
-#ifndef VUINT8x8_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(u, 8, 8, 4)
-# define VUINT8x8_LRSHIFT_DEFINED
-#endif
-
-#ifndef VUINT8x8_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(u, 8, 8, 4)
-# define VUINT8x8_LSHIFT_DEFINED
-#endif
-
-
-
-/* vuint8x16 */
-
-#ifndef VINT8x16_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(/* nothing */, 8, 16, 8)
-# define VINT8x16_SPLAT_DEFINED
-#endif
-
-#ifndef VINT8x16_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 8, 16, 8)
-# define VINT8x16_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT8x16_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(/* nothing */, 8, 16, 8)
-# define VINT8x16_LOAD_DEFINED
-#endif
-
-#ifndef VINT8x16_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 8, 16, 8)
-# define VINT8x16_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT8x16_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(/* nothing */, 8, 16, 8)
-# define VINT8x16_STORE_DEFINED
-#endif
-
-#ifndef VINT8x16_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(/* nothing */, 8, 16, 8)
-# define VINT8x16_ADD_DEFINED
-#endif
-
-#ifndef VINT8x16_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(/* nothing */, 8, 16, 8)
-# define VINT8x16_SUB_DEFINED
-#endif
-
-#ifndef VINT8x16_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(/* nothing */, 8, 16, 8)
-# define VINT8x16_MUL_DEFINED
-#endif
-
-#ifndef VINT8x16_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(/* nothing */, 8, 16, 8)
-# define VINT8x16_DIV_DEFINED
-#endif
-
-#ifndef VINT8x16_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(/* nothing */, 8, 16, 8)
-# define VINT8x16_MOD_DEFINED
-#endif
-
-#ifndef VINT8x16_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(/* nothing */, 8, 16, 8)
-# define VINT8x16_AVG_DEFINED
-#endif
-
-#ifndef VINT8x16_AND_DEFINED
-VEC_GENERIC_DBL_AND(/* nothing */, 8, 16, 8)
-# define VINT8x16_AND_DEFINED
-#endif
-
-#ifndef VINT8x16_OR_DEFINED
-VEC_GENERIC_DBL_OR(/* nothing */, 8, 16, 8)
-# define VINT8x16_OR_DEFINED
-#endif
-
-#ifndef VINT8x16_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(/* nothing */, 8, 16, 8)
-# define VINT8x16_XOR_DEFINED
-#endif
-
-#ifndef VINT8x16_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(/* nothing */, 8, 16, 8)
-# define VINT8x16_NOT_DEFINED
-#endif
-
-#ifndef VINT8x16_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(/* nothing */, 8, 16, 8)
-# define VINT8x16_CMPLT_DEFINED
-#endif
-
-#ifndef VINT8x16_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(/* nothing */, 8, 16, 8)
-# define VINT8x16_CMPEQ_DEFINED
-#endif
-
-#ifndef VINT8x16_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(/* nothing */, 8, 16, 8)
-# define VINT8x16_CMPGT_DEFINED
-#endif
-
-#ifndef VINT8x16_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(/* nothing */, 8, 16, 8)
-# define VINT8x16_CMPLE_DEFINED
-#endif
-
-#ifndef VINT8x16_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(/* nothing */, 8, 16, 8)
-# define VINT8x16_CMPGE_DEFINED
-#endif
-
-#ifndef VINT8x16_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(/* nothing */, 8, 16, 8)
-# define VINT8x16_MIN_DEFINED
-#endif
-
-#ifndef VINT8x16_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(/* nothing */, 8, 16, 8)
-# define VINT8x16_MAX_DEFINED
-#endif
-
-#ifndef VINT8x16_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(/* nothing */, 8, 16, 8)
-# define VINT8x16_RSHIFT_DEFINED
-#endif
-
-#ifndef VINT8x16_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 8, 16, 8)
-# define VINT8x16_LRSHIFT_DEFINED
-#endif
-
-#ifndef VINT8x16_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(/* nothing */, 8, 16, 8)
-# define VINT8x16_LSHIFT_DEFINED
-#endif
-
-
-
-/* vint8x16 */
-
-#ifndef VUINT8x16_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(u, 8, 16, 8)
-# define VUINT8x16_SPLAT_DEFINED
-#endif
-
-#ifndef VUINT8x16_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(u, 8, 16, 8)
-# define VUINT8x16_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT8x16_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(u, 8, 16, 8)
-# define VUINT8x16_LOAD_DEFINED
-#endif
-
-#ifndef VUINT8x16_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(u, 8, 16, 8)
-# define VUINT8x16_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT8x16_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(u, 8, 16, 8)
-# define VUINT8x16_STORE_DEFINED
-#endif
-
-#ifndef VUINT8x16_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(u, 8, 16, 8)
-# define VUINT8x16_ADD_DEFINED
-#endif
-
-#ifndef VUINT8x16_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(u, 8, 16, 8)
-# define VUINT8x16_SUB_DEFINED
-#endif
-
-#ifndef VUINT8x16_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(u, 8, 16, 8)
-# define VUINT8x16_MUL_DEFINED
-#endif
-
-#ifndef VUINT8x16_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(u, 8, 16, 8)
-# define VUINT8x16_DIV_DEFINED
-#endif
-
-#ifndef VUINT8x16_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(u, 8, 16, 8)
-# define VUINT8x16_MOD_DEFINED
-#endif
-
-#ifndef VUINT8x16_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(u, 8, 16, 8)
-# define VUINT8x16_AVG_DEFINED
-#endif
-
-#ifndef VUINT8x16_AND_DEFINED
-VEC_GENERIC_DBL_AND(u, 8, 16, 8)
-# define VUINT8x16_AND_DEFINED
-#endif
-
-#ifndef VUINT8x16_OR_DEFINED
-VEC_GENERIC_DBL_OR(u, 8, 16, 8)
-# define VUINT8x16_OR_DEFINED
-#endif
-
-#ifndef VUINT8x16_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(u, 8, 16, 8)
-# define VUINT8x16_XOR_DEFINED
-#endif
-
-#ifndef VUINT8x16_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(u, 8, 16, 8)
-# define VUINT8x16_NOT_DEFINED
-#endif
-
-#ifndef VUINT8x16_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(u, 8, 16, 8)
-# define VUINT8x16_CMPLT_DEFINED
-#endif
-
-#ifndef VUINT8x16_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(u, 8, 16, 8)
-# define VUINT8x16_CMPEQ_DEFINED
-#endif
-
-#ifndef VUINT8x16_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(u, 8, 16, 8)
-# define VUINT8x16_CMPGT_DEFINED
-#endif
-
-#ifndef VUINT8x16_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(u, 8, 16, 8)
-# define VUINT8x16_CMPLE_DEFINED
-#endif
-
-#ifndef VUINT8x16_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(u, 8, 16, 8)
-# define VUINT8x16_CMPGE_DEFINED
-#endif
-
-#ifndef VUINT8x16_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(u, 8, 16, 8)
-# define VUINT8x16_MIN_DEFINED
-#endif
-
-#ifndef VUINT8x16_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(u, 8, 16, 8)
-# define VUINT8x16_MAX_DEFINED
-#endif
-
-#ifndef VUINT8x16_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(u, 8, 16, 8)
-# define VUINT8x16_RSHIFT_DEFINED
-#endif
-
-#ifndef VUINT8x16_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(u, 8, 16, 8)
-# define VUINT8x16_LRSHIFT_DEFINED
-#endif
-
-#ifndef VUINT8x16_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(u, 8, 16, 8)
-# define VUINT8x16_LSHIFT_DEFINED
-#endif
-
-
-
-/* vuint8x32 */
-
-#ifndef VINT8x32_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(/* nothing */, 8, 32, 16)
-# define VINT8x32_SPLAT_DEFINED
-#endif
-
-#ifndef VINT8x32_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 8, 32, 16)
-# define VINT8x32_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT8x32_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(/* nothing */, 8, 32, 16)
-# define VINT8x32_LOAD_DEFINED
-#endif
-
-#ifndef VINT8x32_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 8, 32, 16)
-# define VINT8x32_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT8x32_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(/* nothing */, 8, 32, 16)
-# define VINT8x32_STORE_DEFINED
-#endif
-
-#ifndef VINT8x32_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(/* nothing */, 8, 32, 16)
-# define VINT8x32_ADD_DEFINED
-#endif
-
-#ifndef VINT8x32_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(/* nothing */, 8, 32, 16)
-# define VINT8x32_SUB_DEFINED
-#endif
-
-#ifndef VINT8x32_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(/* nothing */, 8, 32, 16)
-# define VINT8x32_MUL_DEFINED
-#endif
-
-#ifndef VINT8x32_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(/* nothing */, 8, 32, 16)
-# define VINT8x32_DIV_DEFINED
-#endif
-
-#ifndef VINT8x32_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(/* nothing */, 8, 32, 16)
-# define VINT8x32_MOD_DEFINED
-#endif
-
-#ifndef VINT8x32_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(/* nothing */, 8, 32, 16)
-# define VINT8x32_AVG_DEFINED
-#endif
-
-#ifndef VINT8x32_AND_DEFINED
-VEC_GENERIC_DBL_AND(/* nothing */, 8, 32, 16)
-# define VINT8x32_AND_DEFINED
-#endif
-
-#ifndef VINT8x32_OR_DEFINED
-VEC_GENERIC_DBL_OR(/* nothing */, 8, 32, 16)
-# define VINT8x32_OR_DEFINED
-#endif
-
-#ifndef VINT8x32_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(/* nothing */, 8, 32, 16)
-# define VINT8x32_XOR_DEFINED
-#endif
-
-#ifndef VINT8x32_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(/* nothing */, 8, 32, 16)
-# define VINT8x32_NOT_DEFINED
-#endif
-
-#ifndef VINT8x32_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(/* nothing */, 8, 32, 16)
-# define VINT8x32_CMPLT_DEFINED
-#endif
-
-#ifndef VINT8x32_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(/* nothing */, 8, 32, 16)
-# define VINT8x32_CMPEQ_DEFINED
-#endif
-
-#ifndef VINT8x32_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(/* nothing */, 8, 32, 16)
-# define VINT8x32_CMPGT_DEFINED
-#endif
-
-#ifndef VINT8x32_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(/* nothing */, 8, 32, 16)
-# define VINT8x32_CMPLE_DEFINED
-#endif
-
-#ifndef VINT8x32_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(/* nothing */, 8, 32, 16)
-# define VINT8x32_CMPGE_DEFINED
-#endif
-
-#ifndef VINT8x32_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(/* nothing */, 8, 32, 16)
-# define VINT8x32_MIN_DEFINED
-#endif
-
-#ifndef VINT8x32_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(/* nothing */, 8, 32, 16)
-# define VINT8x32_MAX_DEFINED
-#endif
-
-#ifndef VINT8x32_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(/* nothing */, 8, 32, 16)
-# define VINT8x32_RSHIFT_DEFINED
-#endif
-
-#ifndef VINT8x32_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 8, 32, 16)
-# define VINT8x32_LRSHIFT_DEFINED
-#endif
-
-#ifndef VINT8x32_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(/* nothing */, 8, 32, 16)
-# define VINT8x32_LSHIFT_DEFINED
-#endif
-
-
-
-/* vint8x32 */
-
-#ifndef VUINT8x32_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(u, 8, 32, 16)
-# define VUINT8x32_SPLAT_DEFINED
-#endif
-
-#ifndef VUINT8x32_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(u, 8, 32, 16)
-# define VUINT8x32_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT8x32_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(u, 8, 32, 16)
-# define VUINT8x32_LOAD_DEFINED
-#endif
-
-#ifndef VUINT8x32_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(u, 8, 32, 16)
-# define VUINT8x32_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT8x32_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(u, 8, 32, 16)
-# define VUINT8x32_STORE_DEFINED
-#endif
-
-#ifndef VUINT8x32_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(u, 8, 32, 16)
-# define VUINT8x32_ADD_DEFINED
-#endif
-
-#ifndef VUINT8x32_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(u, 8, 32, 16)
-# define VUINT8x32_SUB_DEFINED
-#endif
-
-#ifndef VUINT8x32_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(u, 8, 32, 16)
-# define VUINT8x32_MUL_DEFINED
-#endif
-
-#ifndef VUINT8x32_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(u, 8, 32, 16)
-# define VUINT8x32_DIV_DEFINED
-#endif
-
-#ifndef VUINT8x32_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(u, 8, 32, 16)
-# define VUINT8x32_MOD_DEFINED
-#endif
-
-#ifndef VUINT8x32_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(u, 8, 32, 16)
-# define VUINT8x32_AVG_DEFINED
-#endif
-
-#ifndef VUINT8x32_AND_DEFINED
-VEC_GENERIC_DBL_AND(u, 8, 32, 16)
-# define VUINT8x32_AND_DEFINED
-#endif
-
-#ifndef VUINT8x32_OR_DEFINED
-VEC_GENERIC_DBL_OR(u, 8, 32, 16)
-# define VUINT8x32_OR_DEFINED
-#endif
-
-#ifndef VUINT8x32_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(u, 8, 32, 16)
-# define VUINT8x32_XOR_DEFINED
-#endif
-
-#ifndef VUINT8x32_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(u, 8, 32, 16)
-# define VUINT8x32_NOT_DEFINED
-#endif
-
-#ifndef VUINT8x32_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(u, 8, 32, 16)
-# define VUINT8x32_CMPLT_DEFINED
-#endif
-
-#ifndef VUINT8x32_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(u, 8, 32, 16)
-# define VUINT8x32_CMPEQ_DEFINED
-#endif
-
-#ifndef VUINT8x32_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(u, 8, 32, 16)
-# define VUINT8x32_CMPGT_DEFINED
-#endif
-
-#ifndef VUINT8x32_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(u, 8, 32, 16)
-# define VUINT8x32_CMPLE_DEFINED
-#endif
-
-#ifndef VUINT8x32_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(u, 8, 32, 16)
-# define VUINT8x32_CMPGE_DEFINED
-#endif
-
-#ifndef VUINT8x32_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(u, 8, 32, 16)
-# define VUINT8x32_MIN_DEFINED
-#endif
-
-#ifndef VUINT8x32_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(u, 8, 32, 16)
-# define VUINT8x32_MAX_DEFINED
-#endif
-
-#ifndef VUINT8x32_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(u, 8, 32, 16)
-# define VUINT8x32_RSHIFT_DEFINED
-#endif
-
-#ifndef VUINT8x32_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(u, 8, 32, 16)
-# define VUINT8x32_LRSHIFT_DEFINED
-#endif
-
-#ifndef VUINT8x32_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(u, 8, 32, 16)
-# define VUINT8x32_LSHIFT_DEFINED
-#endif
-
-
-
-/* vuint8x64 */
-
-#ifndef VINT8x64_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(/* nothing */, 8, 64, 32)
-# define VINT8x64_SPLAT_DEFINED
-#endif
-
-#ifndef VINT8x64_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 8, 64, 32)
-# define VINT8x64_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT8x64_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(/* nothing */, 8, 64, 32)
-# define VINT8x64_LOAD_DEFINED
-#endif
-
-#ifndef VINT8x64_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 8, 64, 32)
-# define VINT8x64_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT8x64_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(/* nothing */, 8, 64, 32)
-# define VINT8x64_STORE_DEFINED
-#endif
-
-#ifndef VINT8x64_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(/* nothing */, 8, 64, 32)
-# define VINT8x64_ADD_DEFINED
-#endif
-
-#ifndef VINT8x64_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(/* nothing */, 8, 64, 32)
-# define VINT8x64_SUB_DEFINED
-#endif
-
-#ifndef VINT8x64_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(/* nothing */, 8, 64, 32)
-# define VINT8x64_MUL_DEFINED
-#endif
-
-#ifndef VINT8x64_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(/* nothing */, 8, 64, 32)
-# define VINT8x64_DIV_DEFINED
-#endif
-
-#ifndef VINT8x64_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(/* nothing */, 8, 64, 32)
-# define VINT8x64_MOD_DEFINED
-#endif
-
-#ifndef VINT8x64_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(/* nothing */, 8, 64, 32)
-# define VINT8x64_AVG_DEFINED
-#endif
-
-#ifndef VINT8x64_AND_DEFINED
-VEC_GENERIC_DBL_AND(/* nothing */, 8, 64, 32)
-# define VINT8x64_AND_DEFINED
-#endif
-
-#ifndef VINT8x64_OR_DEFINED
-VEC_GENERIC_DBL_OR(/* nothing */, 8, 64, 32)
-# define VINT8x64_OR_DEFINED
-#endif
-
-#ifndef VINT8x64_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(/* nothing */, 8, 64, 32)
-# define VINT8x64_XOR_DEFINED
-#endif
-
-#ifndef VINT8x64_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(/* nothing */, 8, 64, 32)
-# define VINT8x64_NOT_DEFINED
-#endif
-
-#ifndef VINT8x64_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(/* nothing */, 8, 64, 32)
-# define VINT8x64_CMPLT_DEFINED
-#endif
-
-#ifndef VINT8x64_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(/* nothing */, 8, 64, 32)
-# define VINT8x64_CMPEQ_DEFINED
-#endif
-
-#ifndef VINT8x64_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(/* nothing */, 8, 64, 32)
-# define VINT8x64_CMPGT_DEFINED
-#endif
-
-#ifndef VINT8x64_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(/* nothing */, 8, 64, 32)
-# define VINT8x64_CMPLE_DEFINED
-#endif
-
-#ifndef VINT8x64_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(/* nothing */, 8, 64, 32)
-# define VINT8x64_CMPGE_DEFINED
-#endif
-
-#ifndef VINT8x64_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(/* nothing */, 8, 64, 32)
-# define VINT8x64_MIN_DEFINED
-#endif
-
-#ifndef VINT8x64_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(/* nothing */, 8, 64, 32)
-# define VINT8x64_MAX_DEFINED
-#endif
-
-#ifndef VINT8x64_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(/* nothing */, 8, 64, 32)
-# define VINT8x64_RSHIFT_DEFINED
-#endif
-
-#ifndef VINT8x64_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 8, 64, 32)
-# define VINT8x64_LRSHIFT_DEFINED
-#endif
-
-#ifndef VINT8x64_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(/* nothing */, 8, 64, 32)
-# define VINT8x64_LSHIFT_DEFINED
-#endif
-
-
-
-/* vint8x64 */
-
-#ifndef VUINT8x64_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(u, 8, 64, 32)
-# define VUINT8x64_SPLAT_DEFINED
-#endif
-
-#ifndef VUINT8x64_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(u, 8, 64, 32)
-# define VUINT8x64_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT8x64_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(u, 8, 64, 32)
-# define VUINT8x64_LOAD_DEFINED
-#endif
-
-#ifndef VUINT8x64_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(u, 8, 64, 32)
-# define VUINT8x64_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT8x64_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(u, 8, 64, 32)
-# define VUINT8x64_STORE_DEFINED
-#endif
-
-#ifndef VUINT8x64_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(u, 8, 64, 32)
-# define VUINT8x64_ADD_DEFINED
-#endif
-
-#ifndef VUINT8x64_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(u, 8, 64, 32)
-# define VUINT8x64_SUB_DEFINED
-#endif
-
-#ifndef VUINT8x64_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(u, 8, 64, 32)
-# define VUINT8x64_MUL_DEFINED
-#endif
-
-#ifndef VUINT8x64_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(u, 8, 64, 32)
-# define VUINT8x64_DIV_DEFINED
-#endif
-
-#ifndef VUINT8x64_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(u, 8, 64, 32)
-# define VUINT8x64_MOD_DEFINED
-#endif
-
-#ifndef VUINT8x64_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(u, 8, 64, 32)
-# define VUINT8x64_AVG_DEFINED
-#endif
-
-#ifndef VUINT8x64_AND_DEFINED
-VEC_GENERIC_DBL_AND(u, 8, 64, 32)
-# define VUINT8x64_AND_DEFINED
-#endif
-
-#ifndef VUINT8x64_OR_DEFINED
-VEC_GENERIC_DBL_OR(u, 8, 64, 32)
-# define VUINT8x64_OR_DEFINED
-#endif
-
-#ifndef VUINT8x64_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(u, 8, 64, 32)
-# define VUINT8x64_XOR_DEFINED
-#endif
-
-#ifndef VUINT8x64_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(u, 8, 64, 32)
-# define VUINT8x64_NOT_DEFINED
-#endif
-
-#ifndef VUINT8x64_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(u, 8, 64, 32)
-# define VUINT8x64_CMPLT_DEFINED
-#endif
-
-#ifndef VUINT8x64_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(u, 8, 64, 32)
-# define VUINT8x64_CMPEQ_DEFINED
-#endif
-
-#ifndef VUINT8x64_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(u, 8, 64, 32)
-# define VUINT8x64_CMPGT_DEFINED
-#endif
-
-#ifndef VUINT8x64_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(u, 8, 64, 32)
-# define VUINT8x64_CMPLE_DEFINED
-#endif
-
-#ifndef VUINT8x64_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(u, 8, 64, 32)
-# define VUINT8x64_CMPGE_DEFINED
-#endif
-
-#ifndef VUINT8x64_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(u, 8, 64, 32)
-# define VUINT8x64_MIN_DEFINED
-#endif
-
-#ifndef VUINT8x64_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(u, 8, 64, 32)
-# define VUINT8x64_MAX_DEFINED
-#endif
-
-#ifndef VUINT8x64_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(u, 8, 64, 32)
-# define VUINT8x64_RSHIFT_DEFINED
-#endif
-
-#ifndef VUINT8x64_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(u, 8, 64, 32)
-# define VUINT8x64_LRSHIFT_DEFINED
-#endif
-
-#ifndef VUINT8x64_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(u, 8, 64, 32)
-# define VUINT8x64_LSHIFT_DEFINED
-#endif
-
-
-
 /* vuint16x2 */
 
 #ifndef VINT16x2_SPLAT_DEFINED
@@ -1992,1038 +629,6 @@
 #endif
 
 
-/* vuint16x4 */
-
-#ifndef VINT16x4_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(/* nothing */, 16, 4, 2)
-# define VINT16x4_SPLAT_DEFINED
-#endif
-
-#ifndef VINT16x4_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 16, 4, 2)
-# define VINT16x4_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT16x4_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(/* nothing */, 16, 4, 2)
-# define VINT16x4_LOAD_DEFINED
-#endif
-
-#ifndef VINT16x4_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 16, 4, 2)
-# define VINT16x4_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT16x4_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(/* nothing */, 16, 4, 2)
-# define VINT16x4_STORE_DEFINED
-#endif
-
-#ifndef VINT16x4_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(/* nothing */, 16, 4, 2)
-# define VINT16x4_ADD_DEFINED
-#endif
-
-#ifndef VINT16x4_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(/* nothing */, 16, 4, 2)
-# define VINT16x4_SUB_DEFINED
-#endif
-
-#ifndef VINT16x4_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(/* nothing */, 16, 4, 2)
-# define VINT16x4_MUL_DEFINED
-#endif
-
-#ifndef VINT16x4_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(/* nothing */, 16, 4, 2)
-# define VINT16x4_DIV_DEFINED
-#endif
-
-#ifndef VINT16x4_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(/* nothing */, 16, 4, 2)
-# define VINT16x4_MOD_DEFINED
-#endif
-
-#ifndef VINT16x4_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(/* nothing */, 16, 4, 2)
-# define VINT16x4_AVG_DEFINED
-#endif
-
-#ifndef VINT16x4_AND_DEFINED
-VEC_GENERIC_DBL_AND(/* nothing */, 16, 4, 2)
-# define VINT16x4_AND_DEFINED
-#endif
-
-#ifndef VINT16x4_OR_DEFINED
-VEC_GENERIC_DBL_OR(/* nothing */, 16, 4, 2)
-# define VINT16x4_OR_DEFINED
-#endif
-
-#ifndef VINT16x4_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(/* nothing */, 16, 4, 2)
-# define VINT16x4_XOR_DEFINED
-#endif
-
-#ifndef VINT16x4_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(/* nothing */, 16, 4, 2)
-# define VINT16x4_NOT_DEFINED
-#endif
-
-#ifndef VINT16x4_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(/* nothing */, 16, 4, 2)
-# define VINT16x4_CMPLT_DEFINED
-#endif
-
-#ifndef VINT16x4_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(/* nothing */, 16, 4, 2)
-# define VINT16x4_CMPEQ_DEFINED
-#endif
-
-#ifndef VINT16x4_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(/* nothing */, 16, 4, 2)
-# define VINT16x4_CMPGT_DEFINED
-#endif
-
-#ifndef VINT16x4_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(/* nothing */, 16, 4, 2)
-# define VINT16x4_CMPLE_DEFINED
-#endif
-
-#ifndef VINT16x4_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(/* nothing */, 16, 4, 2)
-# define VINT16x4_CMPGE_DEFINED
-#endif
-
-#ifndef VINT16x4_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(/* nothing */, 16, 4, 2)
-# define VINT16x4_MIN_DEFINED
-#endif
-
-#ifndef VINT16x4_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(/* nothing */, 16, 4, 2)
-# define VINT16x4_MAX_DEFINED
-#endif
-
-#ifndef VINT16x4_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(/* nothing */, 16, 4, 2)
-# define VINT16x4_RSHIFT_DEFINED
-#endif
-
-#ifndef VINT16x4_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 16, 4, 2)
-# define VINT16x4_LRSHIFT_DEFINED
-#endif
-
-#ifndef VINT16x4_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(/* nothing */, 16, 4, 2)
-# define VINT16x4_LSHIFT_DEFINED
-#endif
-
-
-
-/* vint16x4 */
-
-#ifndef VUINT16x4_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(u, 16, 4, 2)
-# define VUINT16x4_SPLAT_DEFINED
-#endif
-
-#ifndef VUINT16x4_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(u, 16, 4, 2)
-# define VUINT16x4_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT16x4_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(u, 16, 4, 2)
-# define VUINT16x4_LOAD_DEFINED
-#endif
-
-#ifndef VUINT16x4_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(u, 16, 4, 2)
-# define VUINT16x4_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT16x4_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(u, 16, 4, 2)
-# define VUINT16x4_STORE_DEFINED
-#endif
-
-#ifndef VUINT16x4_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(u, 16, 4, 2)
-# define VUINT16x4_ADD_DEFINED
-#endif
-
-#ifndef VUINT16x4_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(u, 16, 4, 2)
-# define VUINT16x4_SUB_DEFINED
-#endif
-
-#ifndef VUINT16x4_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(u, 16, 4, 2)
-# define VUINT16x4_MUL_DEFINED
-#endif
-
-#ifndef VUINT16x4_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(u, 16, 4, 2)
-# define VUINT16x4_DIV_DEFINED
-#endif
-
-#ifndef VUINT16x4_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(u, 16, 4, 2)
-# define VUINT16x4_MOD_DEFINED
-#endif
-
-#ifndef VUINT16x4_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(u, 16, 4, 2)
-# define VUINT16x4_AVG_DEFINED
-#endif
-
-#ifndef VUINT16x4_AND_DEFINED
-VEC_GENERIC_DBL_AND(u, 16, 4, 2)
-# define VUINT16x4_AND_DEFINED
-#endif
-
-#ifndef VUINT16x4_OR_DEFINED
-VEC_GENERIC_DBL_OR(u, 16, 4, 2)
-# define VUINT16x4_OR_DEFINED
-#endif
-
-#ifndef VUINT16x4_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(u, 16, 4, 2)
-# define VUINT16x4_XOR_DEFINED
-#endif
-
-#ifndef VUINT16x4_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(u, 16, 4, 2)
-# define VUINT16x4_NOT_DEFINED
-#endif
-
-#ifndef VUINT16x4_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(u, 16, 4, 2)
-# define VUINT16x4_CMPLT_DEFINED
-#endif
-
-#ifndef VUINT16x4_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(u, 16, 4, 2)
-# define VUINT16x4_CMPEQ_DEFINED
-#endif
-
-#ifndef VUINT16x4_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(u, 16, 4, 2)
-# define VUINT16x4_CMPGT_DEFINED
-#endif
-
-#ifndef VUINT16x4_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(u, 16, 4, 2)
-# define VUINT16x4_CMPLE_DEFINED
-#endif
-
-#ifndef VUINT16x4_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(u, 16, 4, 2)
-# define VUINT16x4_CMPGE_DEFINED
-#endif
-
-#ifndef VUINT16x4_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(u, 16, 4, 2)
-# define VUINT16x4_MIN_DEFINED
-#endif
-
-#ifndef VUINT16x4_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(u, 16, 4, 2)
-# define VUINT16x4_MAX_DEFINED
-#endif
-
-#ifndef VUINT16x4_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(u, 16, 4, 2)
-# define VUINT16x4_RSHIFT_DEFINED
-#endif
-
-#ifndef VUINT16x4_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(u, 16, 4, 2)
-# define VUINT16x4_LRSHIFT_DEFINED
-#endif
-
-#ifndef VUINT16x4_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(u, 16, 4, 2)
-# define VUINT16x4_LSHIFT_DEFINED
-#endif
-
-
-
-/* vuint16x8 */
-
-#ifndef VINT16x8_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(/* nothing */, 16, 8, 4)
-# define VINT16x8_SPLAT_DEFINED
-#endif
-
-#ifndef VINT16x8_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 16, 8, 4)
-# define VINT16x8_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT16x8_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(/* nothing */, 16, 8, 4)
-# define VINT16x8_LOAD_DEFINED
-#endif
-
-#ifndef VINT16x8_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 16, 8, 4)
-# define VINT16x8_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT16x8_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(/* nothing */, 16, 8, 4)
-# define VINT16x8_STORE_DEFINED
-#endif
-
-#ifndef VINT16x8_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(/* nothing */, 16, 8, 4)
-# define VINT16x8_ADD_DEFINED
-#endif
-
-#ifndef VINT16x8_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(/* nothing */, 16, 8, 4)
-# define VINT16x8_SUB_DEFINED
-#endif
-
-#ifndef VINT16x8_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(/* nothing */, 16, 8, 4)
-# define VINT16x8_MUL_DEFINED
-#endif
-
-#ifndef VINT16x8_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(/* nothing */, 16, 8, 4)
-# define VINT16x8_DIV_DEFINED
-#endif
-
-#ifndef VINT16x8_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(/* nothing */, 16, 8, 4)
-# define VINT16x8_MOD_DEFINED
-#endif
-
-#ifndef VINT16x8_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(/* nothing */, 16, 8, 4)
-# define VINT16x8_AVG_DEFINED
-#endif
-
-#ifndef VINT16x8_AND_DEFINED
-VEC_GENERIC_DBL_AND(/* nothing */, 16, 8, 4)
-# define VINT16x8_AND_DEFINED
-#endif
-
-#ifndef VINT16x8_OR_DEFINED
-VEC_GENERIC_DBL_OR(/* nothing */, 16, 8, 4)
-# define VINT16x8_OR_DEFINED
-#endif
-
-#ifndef VINT16x8_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(/* nothing */, 16, 8, 4)
-# define VINT16x8_XOR_DEFINED
-#endif
-
-#ifndef VINT16x8_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(/* nothing */, 16, 8, 4)
-# define VINT16x8_NOT_DEFINED
-#endif
-
-#ifndef VINT16x8_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(/* nothing */, 16, 8, 4)
-# define VINT16x8_CMPLT_DEFINED
-#endif
-
-#ifndef VINT16x8_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(/* nothing */, 16, 8, 4)
-# define VINT16x8_CMPEQ_DEFINED
-#endif
-
-#ifndef VINT16x8_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(/* nothing */, 16, 8, 4)
-# define VINT16x8_CMPGT_DEFINED
-#endif
-
-#ifndef VINT16x8_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(/* nothing */, 16, 8, 4)
-# define VINT16x8_CMPLE_DEFINED
-#endif
-
-#ifndef VINT16x8_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(/* nothing */, 16, 8, 4)
-# define VINT16x8_CMPGE_DEFINED
-#endif
-
-#ifndef VINT16x8_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(/* nothing */, 16, 8, 4)
-# define VINT16x8_MIN_DEFINED
-#endif
-
-#ifndef VINT16x8_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(/* nothing */, 16, 8, 4)
-# define VINT16x8_MAX_DEFINED
-#endif
-
-#ifndef VINT16x8_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(/* nothing */, 16, 8, 4)
-# define VINT16x8_RSHIFT_DEFINED
-#endif
-
-#ifndef VINT16x8_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 16, 8, 4)
-# define VINT16x8_LRSHIFT_DEFINED
-#endif
-
-#ifndef VINT16x8_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(/* nothing */, 16, 8, 4)
-# define VINT16x8_LSHIFT_DEFINED
-#endif
-
-
-
-/* vint16x8 */
-
-#ifndef VUINT16x8_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(u, 16, 8, 4)
-# define VUINT16x8_SPLAT_DEFINED
-#endif
-
-#ifndef VUINT16x8_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(u, 16, 8, 4)
-# define VUINT16x8_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT16x8_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(u, 16, 8, 4)
-# define VUINT16x8_LOAD_DEFINED
-#endif
-
-#ifndef VUINT16x8_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(u, 16, 8, 4)
-# define VUINT16x8_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT16x8_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(u, 16, 8, 4)
-# define VUINT16x8_STORE_DEFINED
-#endif
-
-#ifndef VUINT16x8_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(u, 16, 8, 4)
-# define VUINT16x8_ADD_DEFINED
-#endif
-
-#ifndef VUINT16x8_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(u, 16, 8, 4)
-# define VUINT16x8_SUB_DEFINED
-#endif
-
-#ifndef VUINT16x8_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(u, 16, 8, 4)
-# define VUINT16x8_MUL_DEFINED
-#endif
-
-#ifndef VUINT16x8_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(u, 16, 8, 4)
-# define VUINT16x8_DIV_DEFINED
-#endif
-
-#ifndef VUINT16x8_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(u, 16, 8, 4)
-# define VUINT16x8_MOD_DEFINED
-#endif
-
-#ifndef VUINT16x8_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(u, 16, 8, 4)
-# define VUINT16x8_AVG_DEFINED
-#endif
-
-#ifndef VUINT16x8_AND_DEFINED
-VEC_GENERIC_DBL_AND(u, 16, 8, 4)
-# define VUINT16x8_AND_DEFINED
-#endif
-
-#ifndef VUINT16x8_OR_DEFINED
-VEC_GENERIC_DBL_OR(u, 16, 8, 4)
-# define VUINT16x8_OR_DEFINED
-#endif
-
-#ifndef VUINT16x8_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(u, 16, 8, 4)
-# define VUINT16x8_XOR_DEFINED
-#endif
-
-#ifndef VUINT16x8_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(u, 16, 8, 4)
-# define VUINT16x8_NOT_DEFINED
-#endif
-
-#ifndef VUINT16x8_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(u, 16, 8, 4)
-# define VUINT16x8_CMPLT_DEFINED
-#endif
-
-#ifndef VUINT16x8_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(u, 16, 8, 4)
-# define VUINT16x8_CMPEQ_DEFINED
-#endif
-
-#ifndef VUINT16x8_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(u, 16, 8, 4)
-# define VUINT16x8_CMPGT_DEFINED
-#endif
-
-#ifndef VUINT16x8_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(u, 16, 8, 4)
-# define VUINT16x8_CMPLE_DEFINED
-#endif
-
-#ifndef VUINT16x8_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(u, 16, 8, 4)
-# define VUINT16x8_CMPGE_DEFINED
-#endif
-
-#ifndef VUINT16x8_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(u, 16, 8, 4)
-# define VUINT16x8_MIN_DEFINED
-#endif
-
-#ifndef VUINT16x8_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(u, 16, 8, 4)
-# define VUINT16x8_MAX_DEFINED
-#endif
-
-#ifndef VUINT16x8_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(u, 16, 8, 4)
-# define VUINT16x8_RSHIFT_DEFINED
-#endif
-
-#ifndef VUINT16x8_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(u, 16, 8, 4)
-# define VUINT16x8_LRSHIFT_DEFINED
-#endif
-
-#ifndef VUINT16x8_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(u, 16, 8, 4)
-# define VUINT16x8_LSHIFT_DEFINED
-#endif
-
-
-
-/* vuint16x16 */
-
-#ifndef VINT16x16_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(/* nothing */, 16, 16, 8)
-# define VINT16x16_SPLAT_DEFINED
-#endif
-
-#ifndef VINT16x16_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 16, 16, 8)
-# define VINT16x16_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT16x16_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(/* nothing */, 16, 16, 8)
-# define VINT16x16_LOAD_DEFINED
-#endif
-
-#ifndef VINT16x16_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 16, 16, 8)
-# define VINT16x16_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT16x16_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(/* nothing */, 16, 16, 8)
-# define VINT16x16_STORE_DEFINED
-#endif
-
-#ifndef VINT16x16_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(/* nothing */, 16, 16, 8)
-# define VINT16x16_ADD_DEFINED
-#endif
-
-#ifndef VINT16x16_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(/* nothing */, 16, 16, 8)
-# define VINT16x16_SUB_DEFINED
-#endif
-
-#ifndef VINT16x16_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(/* nothing */, 16, 16, 8)
-# define VINT16x16_MUL_DEFINED
-#endif
-
-#ifndef VINT16x16_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(/* nothing */, 16, 16, 8)
-# define VINT16x16_DIV_DEFINED
-#endif
-
-#ifndef VINT16x16_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(/* nothing */, 16, 16, 8)
-# define VINT16x16_MOD_DEFINED
-#endif
-
-#ifndef VINT16x16_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(/* nothing */, 16, 16, 8)
-# define VINT16x16_AVG_DEFINED
-#endif
-
-#ifndef VINT16x16_AND_DEFINED
-VEC_GENERIC_DBL_AND(/* nothing */, 16, 16, 8)
-# define VINT16x16_AND_DEFINED
-#endif
-
-#ifndef VINT16x16_OR_DEFINED
-VEC_GENERIC_DBL_OR(/* nothing */, 16, 16, 8)
-# define VINT16x16_OR_DEFINED
-#endif
-
-#ifndef VINT16x16_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(/* nothing */, 16, 16, 8)
-# define VINT16x16_XOR_DEFINED
-#endif
-
-#ifndef VINT16x16_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(/* nothing */, 16, 16, 8)
-# define VINT16x16_NOT_DEFINED
-#endif
-
-#ifndef VINT16x16_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(/* nothing */, 16, 16, 8)
-# define VINT16x16_CMPLT_DEFINED
-#endif
-
-#ifndef VINT16x16_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(/* nothing */, 16, 16, 8)
-# define VINT16x16_CMPEQ_DEFINED
-#endif
-
-#ifndef VINT16x16_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(/* nothing */, 16, 16, 8)
-# define VINT16x16_CMPGT_DEFINED
-#endif
-
-#ifndef VINT16x16_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(/* nothing */, 16, 16, 8)
-# define VINT16x16_CMPLE_DEFINED
-#endif
-
-#ifndef VINT16x16_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(/* nothing */, 16, 16, 8)
-# define VINT16x16_CMPGE_DEFINED
-#endif
-
-#ifndef VINT16x16_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(/* nothing */, 16, 16, 8)
-# define VINT16x16_MIN_DEFINED
-#endif
-
-#ifndef VINT16x16_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(/* nothing */, 16, 16, 8)
-# define VINT16x16_MAX_DEFINED
-#endif
-
-#ifndef VINT16x16_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(/* nothing */, 16, 16, 8)
-# define VINT16x16_RSHIFT_DEFINED
-#endif
-
-#ifndef VINT16x16_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 16, 16, 8)
-# define VINT16x16_LRSHIFT_DEFINED
-#endif
-
-#ifndef VINT16x16_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(/* nothing */, 16, 16, 8)
-# define VINT16x16_LSHIFT_DEFINED
-#endif
-
-
-
-/* vint16x16 */
-
-#ifndef VUINT16x16_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(u, 16, 16, 8)
-# define VUINT16x16_SPLAT_DEFINED
-#endif
-
-#ifndef VUINT16x16_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(u, 16, 16, 8)
-# define VUINT16x16_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT16x16_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(u, 16, 16, 8)
-# define VUINT16x16_LOAD_DEFINED
-#endif
-
-#ifndef VUINT16x16_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(u, 16, 16, 8)
-# define VUINT16x16_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT16x16_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(u, 16, 16, 8)
-# define VUINT16x16_STORE_DEFINED
-#endif
-
-#ifndef VUINT16x16_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(u, 16, 16, 8)
-# define VUINT16x16_ADD_DEFINED
-#endif
-
-#ifndef VUINT16x16_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(u, 16, 16, 8)
-# define VUINT16x16_SUB_DEFINED
-#endif
-
-#ifndef VUINT16x16_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(u, 16, 16, 8)
-# define VUINT16x16_MUL_DEFINED
-#endif
-
-#ifndef VUINT16x16_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(u, 16, 16, 8)
-# define VUINT16x16_DIV_DEFINED
-#endif
-
-#ifndef VUINT16x16_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(u, 16, 16, 8)
-# define VUINT16x16_MOD_DEFINED
-#endif
-
-#ifndef VUINT16x16_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(u, 16, 16, 8)
-# define VUINT16x16_AVG_DEFINED
-#endif
-
-#ifndef VUINT16x16_AND_DEFINED
-VEC_GENERIC_DBL_AND(u, 16, 16, 8)
-# define VUINT16x16_AND_DEFINED
-#endif
-
-#ifndef VUINT16x16_OR_DEFINED
-VEC_GENERIC_DBL_OR(u, 16, 16, 8)
-# define VUINT16x16_OR_DEFINED
-#endif
-
-#ifndef VUINT16x16_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(u, 16, 16, 8)
-# define VUINT16x16_XOR_DEFINED
-#endif
-
-#ifndef VUINT16x16_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(u, 16, 16, 8)
-# define VUINT16x16_NOT_DEFINED
-#endif
-
-#ifndef VUINT16x16_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(u, 16, 16, 8)
-# define VUINT16x16_CMPLT_DEFINED
-#endif
-
-#ifndef VUINT16x16_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(u, 16, 16, 8)
-# define VUINT16x16_CMPEQ_DEFINED
-#endif
-
-#ifndef VUINT16x16_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(u, 16, 16, 8)
-# define VUINT16x16_CMPGT_DEFINED
-#endif
-
-#ifndef VUINT16x16_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(u, 16, 16, 8)
-# define VUINT16x16_CMPLE_DEFINED
-#endif
-
-#ifndef VUINT16x16_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(u, 16, 16, 8)
-# define VUINT16x16_CMPGE_DEFINED
-#endif
-
-#ifndef VUINT16x16_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(u, 16, 16, 8)
-# define VUINT16x16_MIN_DEFINED
-#endif
-
-#ifndef VUINT16x16_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(u, 16, 16, 8)
-# define VUINT16x16_MAX_DEFINED
-#endif
-
-#ifndef VUINT16x16_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(u, 16, 16, 8)
-# define VUINT16x16_RSHIFT_DEFINED
-#endif
-
-#ifndef VUINT16x16_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(u, 16, 16, 8)
-# define VUINT16x16_LRSHIFT_DEFINED
-#endif
-
-#ifndef VUINT16x16_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(u, 16, 16, 8)
-# define VUINT16x16_LSHIFT_DEFINED
-#endif
-
-
-
-/* vuint16x32 */
-
-#ifndef VINT16x32_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(/* nothing */, 16, 32, 16)
-# define VINT16x32_SPLAT_DEFINED
-#endif
-
-#ifndef VINT16x32_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 16, 32, 16)
-# define VINT16x32_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT16x32_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(/* nothing */, 16, 32, 16)
-# define VINT16x32_LOAD_DEFINED
-#endif
-
-#ifndef VINT16x32_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 16, 32, 16)
-# define VINT16x32_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT16x32_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(/* nothing */, 16, 32, 16)
-# define VINT16x32_STORE_DEFINED
-#endif
-
-#ifndef VINT16x32_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(/* nothing */, 16, 32, 16)
-# define VINT16x32_ADD_DEFINED
-#endif
-
-#ifndef VINT16x32_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(/* nothing */, 16, 32, 16)
-# define VINT16x32_SUB_DEFINED
-#endif
-
-#ifndef VINT16x32_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(/* nothing */, 16, 32, 16)
-# define VINT16x32_MUL_DEFINED
-#endif
-
-#ifndef VINT16x32_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(/* nothing */, 16, 32, 16)
-# define VINT16x32_DIV_DEFINED
-#endif
-
-#ifndef VINT16x32_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(/* nothing */, 16, 32, 16)
-# define VINT16x32_MOD_DEFINED
-#endif
-
-#ifndef VINT16x32_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(/* nothing */, 16, 32, 16)
-# define VINT16x32_AVG_DEFINED
-#endif
-
-#ifndef VINT16x32_AND_DEFINED
-VEC_GENERIC_DBL_AND(/* nothing */, 16, 32, 16)
-# define VINT16x32_AND_DEFINED
-#endif
-
-#ifndef VINT16x32_OR_DEFINED
-VEC_GENERIC_DBL_OR(/* nothing */, 16, 32, 16)
-# define VINT16x32_OR_DEFINED
-#endif
-
-#ifndef VINT16x32_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(/* nothing */, 16, 32, 16)
-# define VINT16x32_XOR_DEFINED
-#endif
-
-#ifndef VINT16x32_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(/* nothing */, 16, 32, 16)
-# define VINT16x32_NOT_DEFINED
-#endif
-
-#ifndef VINT16x32_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(/* nothing */, 16, 32, 16)
-# define VINT16x32_CMPLT_DEFINED
-#endif
-
-#ifndef VINT16x32_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(/* nothing */, 16, 32, 16)
-# define VINT16x32_CMPEQ_DEFINED
-#endif
-
-#ifndef VINT16x32_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(/* nothing */, 16, 32, 16)
-# define VINT16x32_CMPGT_DEFINED
-#endif
-
-#ifndef VINT16x32_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(/* nothing */, 16, 32, 16)
-# define VINT16x32_CMPLE_DEFINED
-#endif
-
-#ifndef VINT16x32_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(/* nothing */, 16, 32, 16)
-# define VINT16x32_CMPGE_DEFINED
-#endif
-
-#ifndef VINT16x32_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(/* nothing */, 16, 32, 16)
-# define VINT16x32_MIN_DEFINED
-#endif
-
-#ifndef VINT16x32_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(/* nothing */, 16, 32, 16)
-# define VINT16x32_MAX_DEFINED
-#endif
-
-#ifndef VINT16x32_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(/* nothing */, 16, 32, 16)
-# define VINT16x32_RSHIFT_DEFINED
-#endif
-
-#ifndef VINT16x32_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 16, 32, 16)
-# define VINT16x32_LRSHIFT_DEFINED
-#endif
-
-#ifndef VINT16x32_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(/* nothing */, 16, 32, 16)
-# define VINT16x32_LSHIFT_DEFINED
-#endif
-
-
-
-/* vint16x32 */
-
-#ifndef VUINT16x32_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(u, 16, 32, 16)
-# define VUINT16x32_SPLAT_DEFINED
-#endif
-
-#ifndef VUINT16x32_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(u, 16, 32, 16)
-# define VUINT16x32_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT16x32_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(u, 16, 32, 16)
-# define VUINT16x32_LOAD_DEFINED
-#endif
-
-#ifndef VUINT16x32_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(u, 16, 32, 16)
-# define VUINT16x32_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT16x32_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(u, 16, 32, 16)
-# define VUINT16x32_STORE_DEFINED
-#endif
-
-#ifndef VUINT16x32_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(u, 16, 32, 16)
-# define VUINT16x32_ADD_DEFINED
-#endif
-
-#ifndef VUINT16x32_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(u, 16, 32, 16)
-# define VUINT16x32_SUB_DEFINED
-#endif
-
-#ifndef VUINT16x32_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(u, 16, 32, 16)
-# define VUINT16x32_MUL_DEFINED
-#endif
-
-#ifndef VUINT16x32_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(u, 16, 32, 16)
-# define VUINT16x32_DIV_DEFINED
-#endif
-
-#ifndef VUINT16x32_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(u, 16, 32, 16)
-# define VUINT16x32_MOD_DEFINED
-#endif
-
-#ifndef VUINT16x32_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(u, 16, 32, 16)
-# define VUINT16x32_AVG_DEFINED
-#endif
-
-#ifndef VUINT16x32_AND_DEFINED
-VEC_GENERIC_DBL_AND(u, 16, 32, 16)
-# define VUINT16x32_AND_DEFINED
-#endif
-
-#ifndef VUINT16x32_OR_DEFINED
-VEC_GENERIC_DBL_OR(u, 16, 32, 16)
-# define VUINT16x32_OR_DEFINED
-#endif
-
-#ifndef VUINT16x32_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(u, 16, 32, 16)
-# define VUINT16x32_XOR_DEFINED
-#endif
-
-#ifndef VUINT16x32_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(u, 16, 32, 16)
-# define VUINT16x32_NOT_DEFINED
-#endif
-
-#ifndef VUINT16x32_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(u, 16, 32, 16)
-# define VUINT16x32_CMPLT_DEFINED
-#endif
-
-#ifndef VUINT16x32_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(u, 16, 32, 16)
-# define VUINT16x32_CMPEQ_DEFINED
-#endif
-
-#ifndef VUINT16x32_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(u, 16, 32, 16)
-# define VUINT16x32_CMPGT_DEFINED
-#endif
-
-#ifndef VUINT16x32_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(u, 16, 32, 16)
-# define VUINT16x32_CMPLE_DEFINED
-#endif
-
-#ifndef VUINT16x32_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(u, 16, 32, 16)
-# define VUINT16x32_CMPGE_DEFINED
-#endif
-
-#ifndef VUINT16x32_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(u, 16, 32, 16)
-# define VUINT16x32_MIN_DEFINED
-#endif
-
-#ifndef VUINT16x32_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(u, 16, 32, 16)
-# define VUINT16x32_MAX_DEFINED
-#endif
-
-#ifndef VUINT16x32_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(u, 16, 32, 16)
-# define VUINT16x32_RSHIFT_DEFINED
-#endif
-
-#ifndef VUINT16x32_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(u, 16, 32, 16)
-# define VUINT16x32_LRSHIFT_DEFINED
-#endif
-
-#ifndef VUINT16x32_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(u, 16, 32, 16)
-# define VUINT16x32_LSHIFT_DEFINED
-#endif
-
-
-
 /* vuint32x2 */
 
 #ifndef VINT32x2_SPLAT_DEFINED
@@ -3232,780 +837,6 @@
 #endif
 
 
-/* vuint32x4 */
-
-#ifndef VINT32x4_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(/* nothing */, 32, 4, 2)
-# define VINT32x4_SPLAT_DEFINED
-#endif
-
-#ifndef VINT32x4_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 32, 4, 2)
-# define VINT32x4_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT32x4_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(/* nothing */, 32, 4, 2)
-# define VINT32x4_LOAD_DEFINED
-#endif
-
-#ifndef VINT32x4_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 32, 4, 2)
-# define VINT32x4_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT32x4_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(/* nothing */, 32, 4, 2)
-# define VINT32x4_STORE_DEFINED
-#endif
-
-#ifndef VINT32x4_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(/* nothing */, 32, 4, 2)
-# define VINT32x4_ADD_DEFINED
-#endif
-
-#ifndef VINT32x4_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(/* nothing */, 32, 4, 2)
-# define VINT32x4_SUB_DEFINED
-#endif
-
-#ifndef VINT32x4_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(/* nothing */, 32, 4, 2)
-# define VINT32x4_MUL_DEFINED
-#endif
-
-#ifndef VINT32x4_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(/* nothing */, 32, 4, 2)
-# define VINT32x4_DIV_DEFINED
-#endif
-
-#ifndef VINT32x4_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(/* nothing */, 32, 4, 2)
-# define VINT32x4_MOD_DEFINED
-#endif
-
-#ifndef VINT32x4_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(/* nothing */, 32, 4, 2)
-# define VINT32x4_AVG_DEFINED
-#endif
-
-#ifndef VINT32x4_AND_DEFINED
-VEC_GENERIC_DBL_AND(/* nothing */, 32, 4, 2)
-# define VINT32x4_AND_DEFINED
-#endif
-
-#ifndef VINT32x4_OR_DEFINED
-VEC_GENERIC_DBL_OR(/* nothing */, 32, 4, 2)
-# define VINT32x4_OR_DEFINED
-#endif
-
-#ifndef VINT32x4_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(/* nothing */, 32, 4, 2)
-# define VINT32x4_XOR_DEFINED
-#endif
-
-#ifndef VINT32x4_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(/* nothing */, 32, 4, 2)
-# define VINT32x4_NOT_DEFINED
-#endif
-
-#ifndef VINT32x4_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(/* nothing */, 32, 4, 2)
-# define VINT32x4_CMPLT_DEFINED
-#endif
-
-#ifndef VINT32x4_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(/* nothing */, 32, 4, 2)
-# define VINT32x4_CMPEQ_DEFINED
-#endif
-
-#ifndef VINT32x4_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(/* nothing */, 32, 4, 2)
-# define VINT32x4_CMPGT_DEFINED
-#endif
-
-#ifndef VINT32x4_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(/* nothing */, 32, 4, 2)
-# define VINT32x4_CMPLE_DEFINED
-#endif
-
-#ifndef VINT32x4_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(/* nothing */, 32, 4, 2)
-# define VINT32x4_CMPGE_DEFINED
-#endif
-
-#ifndef VINT32x4_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(/* nothing */, 32, 4, 2)
-# define VINT32x4_MIN_DEFINED
-#endif
-
-#ifndef VINT32x4_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(/* nothing */, 32, 4, 2)
-# define VINT32x4_MAX_DEFINED
-#endif
-
-#ifndef VINT32x4_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(/* nothing */, 32, 4, 2)
-# define VINT32x4_RSHIFT_DEFINED
-#endif
-
-#ifndef VINT32x4_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 32, 4, 2)
-# define VINT32x4_LRSHIFT_DEFINED
-#endif
-
-#ifndef VINT32x4_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(/* nothing */, 32, 4, 2)
-# define VINT32x4_LSHIFT_DEFINED
-#endif
-
-
-
-/* vint32x4 */
-
-#ifndef VUINT32x4_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(u, 32, 4, 2)
-# define VUINT32x4_SPLAT_DEFINED
-#endif
-
-#ifndef VUINT32x4_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(u, 32, 4, 2)
-# define VUINT32x4_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT32x4_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(u, 32, 4, 2)
-# define VUINT32x4_LOAD_DEFINED
-#endif
-
-#ifndef VUINT32x4_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(u, 32, 4, 2)
-# define VUINT32x4_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT32x4_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(u, 32, 4, 2)
-# define VUINT32x4_STORE_DEFINED
-#endif
-
-#ifndef VUINT32x4_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(u, 32, 4, 2)
-# define VUINT32x4_ADD_DEFINED
-#endif
-
-#ifndef VUINT32x4_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(u, 32, 4, 2)
-# define VUINT32x4_SUB_DEFINED
-#endif
-
-#ifndef VUINT32x4_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(u, 32, 4, 2)
-# define VUINT32x4_MUL_DEFINED
-#endif
-
-#ifndef VUINT32x4_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(u, 32, 4, 2)
-# define VUINT32x4_DIV_DEFINED
-#endif
-
-#ifndef VUINT32x4_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(u, 32, 4, 2)
-# define VUINT32x4_MOD_DEFINED
-#endif
-
-#ifndef VUINT32x4_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(u, 32, 4, 2)
-# define VUINT32x4_AVG_DEFINED
-#endif
-
-#ifndef VUINT32x4_AND_DEFINED
-VEC_GENERIC_DBL_AND(u, 32, 4, 2)
-# define VUINT32x4_AND_DEFINED
-#endif
-
-#ifndef VUINT32x4_OR_DEFINED
-VEC_GENERIC_DBL_OR(u, 32, 4, 2)
-# define VUINT32x4_OR_DEFINED
-#endif
-
-#ifndef VUINT32x4_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(u, 32, 4, 2)
-# define VUINT32x4_XOR_DEFINED
-#endif
-
-#ifndef VUINT32x4_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(u, 32, 4, 2)
-# define VUINT32x4_NOT_DEFINED
-#endif
-
-#ifndef VUINT32x4_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(u, 32, 4, 2)
-# define VUINT32x4_CMPLT_DEFINED
-#endif
-
-#ifndef VUINT32x4_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(u, 32, 4, 2)
-# define VUINT32x4_CMPEQ_DEFINED
-#endif
-
-#ifndef VUINT32x4_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(u, 32, 4, 2)
-# define VUINT32x4_CMPGT_DEFINED
-#endif
-
-#ifndef VUINT32x4_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(u, 32, 4, 2)
-# define VUINT32x4_CMPLE_DEFINED
-#endif
-
-#ifndef VUINT32x4_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(u, 32, 4, 2)
-# define VUINT32x4_CMPGE_DEFINED
-#endif
-
-#ifndef VUINT32x4_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(u, 32, 4, 2)
-# define VUINT32x4_MIN_DEFINED
-#endif
-
-#ifndef VUINT32x4_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(u, 32, 4, 2)
-# define VUINT32x4_MAX_DEFINED
-#endif
-
-#ifndef VUINT32x4_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(u, 32, 4, 2)
-# define VUINT32x4_RSHIFT_DEFINED
-#endif
-
-#ifndef VUINT32x4_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(u, 32, 4, 2)
-# define VUINT32x4_LRSHIFT_DEFINED
-#endif
-
-#ifndef VUINT32x4_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(u, 32, 4, 2)
-# define VUINT32x4_LSHIFT_DEFINED
-#endif
-
-
-
-/* vuint32x8 */
-
-#ifndef VINT32x8_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(/* nothing */, 32, 8, 4)
-# define VINT32x8_SPLAT_DEFINED
-#endif
-
-#ifndef VINT32x8_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 32, 8, 4)
-# define VINT32x8_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT32x8_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(/* nothing */, 32, 8, 4)
-# define VINT32x8_LOAD_DEFINED
-#endif
-
-#ifndef VINT32x8_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 32, 8, 4)
-# define VINT32x8_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT32x8_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(/* nothing */, 32, 8, 4)
-# define VINT32x8_STORE_DEFINED
-#endif
-
-#ifndef VINT32x8_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(/* nothing */, 32, 8, 4)
-# define VINT32x8_ADD_DEFINED
-#endif
-
-#ifndef VINT32x8_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(/* nothing */, 32, 8, 4)
-# define VINT32x8_SUB_DEFINED
-#endif
-
-#ifndef VINT32x8_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(/* nothing */, 32, 8, 4)
-# define VINT32x8_MUL_DEFINED
-#endif
-
-#ifndef VINT32x8_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(/* nothing */, 32, 8, 4)
-# define VINT32x8_DIV_DEFINED
-#endif
-
-#ifndef VINT32x8_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(/* nothing */, 32, 8, 4)
-# define VINT32x8_MOD_DEFINED
-#endif
-
-#ifndef VINT32x8_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(/* nothing */, 32, 8, 4)
-# define VINT32x8_AVG_DEFINED
-#endif
-
-#ifndef VINT32x8_AND_DEFINED
-VEC_GENERIC_DBL_AND(/* nothing */, 32, 8, 4)
-# define VINT32x8_AND_DEFINED
-#endif
-
-#ifndef VINT32x8_OR_DEFINED
-VEC_GENERIC_DBL_OR(/* nothing */, 32, 8, 4)
-# define VINT32x8_OR_DEFINED
-#endif
-
-#ifndef VINT32x8_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(/* nothing */, 32, 8, 4)
-# define VINT32x8_XOR_DEFINED
-#endif
-
-#ifndef VINT32x8_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(/* nothing */, 32, 8, 4)
-# define VINT32x8_NOT_DEFINED
-#endif
-
-#ifndef VINT32x8_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(/* nothing */, 32, 8, 4)
-# define VINT32x8_CMPLT_DEFINED
-#endif
-
-#ifndef VINT32x8_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(/* nothing */, 32, 8, 4)
-# define VINT32x8_CMPEQ_DEFINED
-#endif
-
-#ifndef VINT32x8_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(/* nothing */, 32, 8, 4)
-# define VINT32x8_CMPGT_DEFINED
-#endif
-
-#ifndef VINT32x8_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(/* nothing */, 32, 8, 4)
-# define VINT32x8_CMPLE_DEFINED
-#endif
-
-#ifndef VINT32x8_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(/* nothing */, 32, 8, 4)
-# define VINT32x8_CMPGE_DEFINED
-#endif
-
-#ifndef VINT32x8_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(/* nothing */, 32, 8, 4)
-# define VINT32x8_MIN_DEFINED
-#endif
-
-#ifndef VINT32x8_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(/* nothing */, 32, 8, 4)
-# define VINT32x8_MAX_DEFINED
-#endif
-
-#ifndef VINT32x8_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(/* nothing */, 32, 8, 4)
-# define VINT32x8_RSHIFT_DEFINED
-#endif
-
-#ifndef VINT32x8_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 32, 8, 4)
-# define VINT32x8_LRSHIFT_DEFINED
-#endif
-
-#ifndef VINT32x8_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(/* nothing */, 32, 8, 4)
-# define VINT32x8_LSHIFT_DEFINED
-#endif
-
-
-
-/* vint32x8 */
-
-#ifndef VUINT32x8_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(u, 32, 8, 4)
-# define VUINT32x8_SPLAT_DEFINED
-#endif
-
-#ifndef VUINT32x8_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(u, 32, 8, 4)
-# define VUINT32x8_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT32x8_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(u, 32, 8, 4)
-# define VUINT32x8_LOAD_DEFINED
-#endif
-
-#ifndef VUINT32x8_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(u, 32, 8, 4)
-# define VUINT32x8_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT32x8_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(u, 32, 8, 4)
-# define VUINT32x8_STORE_DEFINED
-#endif
-
-#ifndef VUINT32x8_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(u, 32, 8, 4)
-# define VUINT32x8_ADD_DEFINED
-#endif
-
-#ifndef VUINT32x8_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(u, 32, 8, 4)
-# define VUINT32x8_SUB_DEFINED
-#endif
-
-#ifndef VUINT32x8_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(u, 32, 8, 4)
-# define VUINT32x8_MUL_DEFINED
-#endif
-
-#ifndef VUINT32x8_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(u, 32, 8, 4)
-# define VUINT32x8_DIV_DEFINED
-#endif
-
-#ifndef VUINT32x8_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(u, 32, 8, 4)
-# define VUINT32x8_MOD_DEFINED
-#endif
-
-#ifndef VUINT32x8_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(u, 32, 8, 4)
-# define VUINT32x8_AVG_DEFINED
-#endif
-
-#ifndef VUINT32x8_AND_DEFINED
-VEC_GENERIC_DBL_AND(u, 32, 8, 4)
-# define VUINT32x8_AND_DEFINED
-#endif
-
-#ifndef VUINT32x8_OR_DEFINED
-VEC_GENERIC_DBL_OR(u, 32, 8, 4)
-# define VUINT32x8_OR_DEFINED
-#endif
-
-#ifndef VUINT32x8_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(u, 32, 8, 4)
-# define VUINT32x8_XOR_DEFINED
-#endif
-
-#ifndef VUINT32x8_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(u, 32, 8, 4)
-# define VUINT32x8_NOT_DEFINED
-#endif
-
-#ifndef VUINT32x8_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(u, 32, 8, 4)
-# define VUINT32x8_CMPLT_DEFINED
-#endif
-
-#ifndef VUINT32x8_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(u, 32, 8, 4)
-# define VUINT32x8_CMPEQ_DEFINED
-#endif
-
-#ifndef VUINT32x8_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(u, 32, 8, 4)
-# define VUINT32x8_CMPGT_DEFINED
-#endif
-
-#ifndef VUINT32x8_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(u, 32, 8, 4)
-# define VUINT32x8_CMPLE_DEFINED
-#endif
-
-#ifndef VUINT32x8_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(u, 32, 8, 4)
-# define VUINT32x8_CMPGE_DEFINED
-#endif
-
-#ifndef VUINT32x8_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(u, 32, 8, 4)
-# define VUINT32x8_MIN_DEFINED
-#endif
-
-#ifndef VUINT32x8_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(u, 32, 8, 4)
-# define VUINT32x8_MAX_DEFINED
-#endif
-
-#ifndef VUINT32x8_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(u, 32, 8, 4)
-# define VUINT32x8_RSHIFT_DEFINED
-#endif
-
-#ifndef VUINT32x8_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(u, 32, 8, 4)
-# define VUINT32x8_LRSHIFT_DEFINED
-#endif
-
-#ifndef VUINT32x8_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(u, 32, 8, 4)
-# define VUINT32x8_LSHIFT_DEFINED
-#endif
-
-
-
-/* vuint32x16 */
-
-#ifndef VINT32x16_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(/* nothing */, 32, 16, 8)
-# define VINT32x16_SPLAT_DEFINED
-#endif
-
-#ifndef VINT32x16_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 32, 16, 8)
-# define VINT32x16_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT32x16_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(/* nothing */, 32, 16, 8)
-# define VINT32x16_LOAD_DEFINED
-#endif
-
-#ifndef VINT32x16_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 32, 16, 8)
-# define VINT32x16_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT32x16_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(/* nothing */, 32, 16, 8)
-# define VINT32x16_STORE_DEFINED
-#endif
-
-#ifndef VINT32x16_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(/* nothing */, 32, 16, 8)
-# define VINT32x16_ADD_DEFINED
-#endif
-
-#ifndef VINT32x16_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(/* nothing */, 32, 16, 8)
-# define VINT32x16_SUB_DEFINED
-#endif
-
-#ifndef VINT32x16_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(/* nothing */, 32, 16, 8)
-# define VINT32x16_MUL_DEFINED
-#endif
-
-#ifndef VINT32x16_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(/* nothing */, 32, 16, 8)
-# define VINT32x16_DIV_DEFINED
-#endif
-
-#ifndef VINT32x16_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(/* nothing */, 32, 16, 8)
-# define VINT32x16_MOD_DEFINED
-#endif
-
-#ifndef VINT32x16_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(/* nothing */, 32, 16, 8)
-# define VINT32x16_AVG_DEFINED
-#endif
-
-#ifndef VINT32x16_AND_DEFINED
-VEC_GENERIC_DBL_AND(/* nothing */, 32, 16, 8)
-# define VINT32x16_AND_DEFINED
-#endif
-
-#ifndef VINT32x16_OR_DEFINED
-VEC_GENERIC_DBL_OR(/* nothing */, 32, 16, 8)
-# define VINT32x16_OR_DEFINED
-#endif
-
-#ifndef VINT32x16_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(/* nothing */, 32, 16, 8)
-# define VINT32x16_XOR_DEFINED
-#endif
-
-#ifndef VINT32x16_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(/* nothing */, 32, 16, 8)
-# define VINT32x16_NOT_DEFINED
-#endif
-
-#ifndef VINT32x16_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(/* nothing */, 32, 16, 8)
-# define VINT32x16_CMPLT_DEFINED
-#endif
-
-#ifndef VINT32x16_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(/* nothing */, 32, 16, 8)
-# define VINT32x16_CMPEQ_DEFINED
-#endif
-
-#ifndef VINT32x16_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(/* nothing */, 32, 16, 8)
-# define VINT32x16_CMPGT_DEFINED
-#endif
-
-#ifndef VINT32x16_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(/* nothing */, 32, 16, 8)
-# define VINT32x16_CMPLE_DEFINED
-#endif
-
-#ifndef VINT32x16_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(/* nothing */, 32, 16, 8)
-# define VINT32x16_CMPGE_DEFINED
-#endif
-
-#ifndef VINT32x16_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(/* nothing */, 32, 16, 8)
-# define VINT32x16_MIN_DEFINED
-#endif
-
-#ifndef VINT32x16_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(/* nothing */, 32, 16, 8)
-# define VINT32x16_MAX_DEFINED
-#endif
-
-#ifndef VINT32x16_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(/* nothing */, 32, 16, 8)
-# define VINT32x16_RSHIFT_DEFINED
-#endif
-
-#ifndef VINT32x16_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 32, 16, 8)
-# define VINT32x16_LRSHIFT_DEFINED
-#endif
-
-#ifndef VINT32x16_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(/* nothing */, 32, 16, 8)
-# define VINT32x16_LSHIFT_DEFINED
-#endif
-
-
-
-/* vint32x16 */
-
-#ifndef VUINT32x16_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(u, 32, 16, 8)
-# define VUINT32x16_SPLAT_DEFINED
-#endif
-
-#ifndef VUINT32x16_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(u, 32, 16, 8)
-# define VUINT32x16_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT32x16_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(u, 32, 16, 8)
-# define VUINT32x16_LOAD_DEFINED
-#endif
-
-#ifndef VUINT32x16_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(u, 32, 16, 8)
-# define VUINT32x16_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT32x16_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(u, 32, 16, 8)
-# define VUINT32x16_STORE_DEFINED
-#endif
-
-#ifndef VUINT32x16_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(u, 32, 16, 8)
-# define VUINT32x16_ADD_DEFINED
-#endif
-
-#ifndef VUINT32x16_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(u, 32, 16, 8)
-# define VUINT32x16_SUB_DEFINED
-#endif
-
-#ifndef VUINT32x16_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(u, 32, 16, 8)
-# define VUINT32x16_MUL_DEFINED
-#endif
-
-#ifndef VUINT32x16_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(u, 32, 16, 8)
-# define VUINT32x16_DIV_DEFINED
-#endif
-
-#ifndef VUINT32x16_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(u, 32, 16, 8)
-# define VUINT32x16_MOD_DEFINED
-#endif
-
-#ifndef VUINT32x16_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(u, 32, 16, 8)
-# define VUINT32x16_AVG_DEFINED
-#endif
-
-#ifndef VUINT32x16_AND_DEFINED
-VEC_GENERIC_DBL_AND(u, 32, 16, 8)
-# define VUINT32x16_AND_DEFINED
-#endif
-
-#ifndef VUINT32x16_OR_DEFINED
-VEC_GENERIC_DBL_OR(u, 32, 16, 8)
-# define VUINT32x16_OR_DEFINED
-#endif
-
-#ifndef VUINT32x16_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(u, 32, 16, 8)
-# define VUINT32x16_XOR_DEFINED
-#endif
-
-#ifndef VUINT32x16_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(u, 32, 16, 8)
-# define VUINT32x16_NOT_DEFINED
-#endif
-
-#ifndef VUINT32x16_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(u, 32, 16, 8)
-# define VUINT32x16_CMPLT_DEFINED
-#endif
-
-#ifndef VUINT32x16_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(u, 32, 16, 8)
-# define VUINT32x16_CMPEQ_DEFINED
-#endif
-
-#ifndef VUINT32x16_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(u, 32, 16, 8)
-# define VUINT32x16_CMPGT_DEFINED
-#endif
-
-#ifndef VUINT32x16_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(u, 32, 16, 8)
-# define VUINT32x16_CMPLE_DEFINED
-#endif
-
-#ifndef VUINT32x16_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(u, 32, 16, 8)
-# define VUINT32x16_CMPGE_DEFINED
-#endif
-
-#ifndef VUINT32x16_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(u, 32, 16, 8)
-# define VUINT32x16_MIN_DEFINED
-#endif
-
-#ifndef VUINT32x16_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(u, 32, 16, 8)
-# define VUINT32x16_MAX_DEFINED
-#endif
-
-#ifndef VUINT32x16_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(u, 32, 16, 8)
-# define VUINT32x16_RSHIFT_DEFINED
-#endif
-
-#ifndef VUINT32x16_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(u, 32, 16, 8)
-# define VUINT32x16_LRSHIFT_DEFINED
-#endif
-
-#ifndef VUINT32x16_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(u, 32, 16, 8)
-# define VUINT32x16_LSHIFT_DEFINED
-#endif
-
-
-
 /* vuint64x2 */
 
 #ifndef VINT64x2_SPLAT_DEFINED
@@ -4212,521 +1043,5 @@
 VEC_GENERIC_LSHIFT(u, 64, 2)
 # define VUINT64x2_LSHIFT_DEFINED
 #endif
-
-
-/* vuint64x4 */
-
-#ifndef VINT64x4_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(/* nothing */, 64, 4, 2)
-# define VINT64x4_SPLAT_DEFINED
-#endif
-
-#ifndef VINT64x4_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 64, 4, 2)
-# define VINT64x4_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT64x4_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(/* nothing */, 64, 4, 2)
-# define VINT64x4_LOAD_DEFINED
-#endif
-
-#ifndef VINT64x4_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 64, 4, 2)
-# define VINT64x4_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT64x4_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(/* nothing */, 64, 4, 2)
-# define VINT64x4_STORE_DEFINED
-#endif
-
-#ifndef VINT64x4_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(/* nothing */, 64, 4, 2)
-# define VINT64x4_ADD_DEFINED
-#endif
-
-#ifndef VINT64x4_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(/* nothing */, 64, 4, 2)
-# define VINT64x4_SUB_DEFINED
-#endif
-
-#ifndef VINT64x4_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(/* nothing */, 64, 4, 2)
-# define VINT64x4_MUL_DEFINED
-#endif
-
-#ifndef VINT64x4_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(/* nothing */, 64, 4, 2)
-# define VINT64x4_DIV_DEFINED
-#endif
-
-#ifndef VINT64x4_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(/* nothing */, 64, 4, 2)
-# define VINT64x4_MOD_DEFINED
-#endif
-
-#ifndef VINT64x4_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(/* nothing */, 64, 4, 2)
-# define VINT64x4_AVG_DEFINED
-#endif
-
-#ifndef VINT64x4_AND_DEFINED
-VEC_GENERIC_DBL_AND(/* nothing */, 64, 4, 2)
-# define VINT64x4_AND_DEFINED
-#endif
-
-#ifndef VINT64x4_OR_DEFINED
-VEC_GENERIC_DBL_OR(/* nothing */, 64, 4, 2)
-# define VINT64x4_OR_DEFINED
-#endif
-
-#ifndef VINT64x4_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(/* nothing */, 64, 4, 2)
-# define VINT64x4_XOR_DEFINED
-#endif
-
-#ifndef VINT64x4_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(/* nothing */, 64, 4, 2)
-# define VINT64x4_NOT_DEFINED
-#endif
-
-#ifndef VINT64x4_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(/* nothing */, 64, 4, 2)
-# define VINT64x4_CMPLT_DEFINED
-#endif
-
-#ifndef VINT64x4_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(/* nothing */, 64, 4, 2)
-# define VINT64x4_CMPEQ_DEFINED
-#endif
-
-#ifndef VINT64x4_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(/* nothing */, 64, 4, 2)
-# define VINT64x4_CMPGT_DEFINED
-#endif
-
-#ifndef VINT64x4_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(/* nothing */, 64, 4, 2)
-# define VINT64x4_CMPLE_DEFINED
-#endif
-
-#ifndef VINT64x4_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(/* nothing */, 64, 4, 2)
-# define VINT64x4_CMPGE_DEFINED
-#endif
-
-#ifndef VINT64x4_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(/* nothing */, 64, 4, 2)
-# define VINT64x4_MIN_DEFINED
-#endif
-
-#ifndef VINT64x4_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(/* nothing */, 64, 4, 2)
-# define VINT64x4_MAX_DEFINED
-#endif
-
-#ifndef VINT64x4_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(/* nothing */, 64, 4, 2)
-# define VINT64x4_RSHIFT_DEFINED
-#endif
-
-#ifndef VINT64x4_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 64, 4, 2)
-# define VINT64x4_LRSHIFT_DEFINED
-#endif
-
-#ifndef VINT64x4_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(/* nothing */, 64, 4, 2)
-# define VINT64x4_LSHIFT_DEFINED
-#endif
-
-
-
-/* vint64x4 */
-
-#ifndef VUINT64x4_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(u, 64, 4, 2)
-# define VUINT64x4_SPLAT_DEFINED
-#endif
-
-#ifndef VUINT64x4_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(u, 64, 4, 2)
-# define VUINT64x4_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT64x4_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(u, 64, 4, 2)
-# define VUINT64x4_LOAD_DEFINED
-#endif
-
-#ifndef VUINT64x4_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(u, 64, 4, 2)
-# define VUINT64x4_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT64x4_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(u, 64, 4, 2)
-# define VUINT64x4_STORE_DEFINED
-#endif
-
-#ifndef VUINT64x4_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(u, 64, 4, 2)
-# define VUINT64x4_ADD_DEFINED
-#endif
-
-#ifndef VUINT64x4_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(u, 64, 4, 2)
-# define VUINT64x4_SUB_DEFINED
-#endif
-
-#ifndef VUINT64x4_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(u, 64, 4, 2)
-# define VUINT64x4_MUL_DEFINED
-#endif
-
-#ifndef VUINT64x4_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(u, 64, 4, 2)
-# define VUINT64x4_DIV_DEFINED
-#endif
-
-#ifndef VUINT64x4_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(u, 64, 4, 2)
-# define VUINT64x4_MOD_DEFINED
-#endif
-
-#ifndef VUINT64x4_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(u, 64, 4, 2)
-# define VUINT64x4_AVG_DEFINED
-#endif
-
-#ifndef VUINT64x4_AND_DEFINED
-VEC_GENERIC_DBL_AND(u, 64, 4, 2)
-# define VUINT64x4_AND_DEFINED
-#endif
-
-#ifndef VUINT64x4_OR_DEFINED
-VEC_GENERIC_DBL_OR(u, 64, 4, 2)
-# define VUINT64x4_OR_DEFINED
-#endif
-
-#ifndef VUINT64x4_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(u, 64, 4, 2)
-# define VUINT64x4_XOR_DEFINED
-#endif
-
-#ifndef VUINT64x4_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(u, 64, 4, 2)
-# define VUINT64x4_NOT_DEFINED
-#endif
-
-#ifndef VUINT64x4_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(u, 64, 4, 2)
-# define VUINT64x4_CMPLT_DEFINED
-#endif
-
-#ifndef VUINT64x4_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(u, 64, 4, 2)
-# define VUINT64x4_CMPEQ_DEFINED
-#endif
-
-#ifndef VUINT64x4_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(u, 64, 4, 2)
-# define VUINT64x4_CMPGT_DEFINED
-#endif
-
-#ifndef VUINT64x4_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(u, 64, 4, 2)
-# define VUINT64x4_CMPLE_DEFINED
-#endif
-
-#ifndef VUINT64x4_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(u, 64, 4, 2)
-# define VUINT64x4_CMPGE_DEFINED
-#endif
-
-#ifndef VUINT64x4_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(u, 64, 4, 2)
-# define VUINT64x4_MIN_DEFINED
-#endif
-
-#ifndef VUINT64x4_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(u, 64, 4, 2)
-# define VUINT64x4_MAX_DEFINED
-#endif
-
-#ifndef VUINT64x4_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(u, 64, 4, 2)
-# define VUINT64x4_RSHIFT_DEFINED
-#endif
-
-#ifndef VUINT64x4_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(u, 64, 4, 2)
-# define VUINT64x4_LRSHIFT_DEFINED
-#endif
-
-#ifndef VUINT64x4_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(u, 64, 4, 2)
-# define VUINT64x4_LSHIFT_DEFINED
-#endif
-
-
-
-/* vuint64x8 */
-
-#ifndef VINT64x8_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(/* nothing */, 64, 8, 4)
-# define VINT64x8_SPLAT_DEFINED
-#endif
-
-#ifndef VINT64x8_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(/* nothing */, 64, 8, 4)
-# define VINT64x8_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT64x8_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(/* nothing */, 64, 8, 4)
-# define VINT64x8_LOAD_DEFINED
-#endif
-
-#ifndef VINT64x8_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(/* nothing */, 64, 8, 4)
-# define VINT64x8_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VINT64x8_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(/* nothing */, 64, 8, 4)
-# define VINT64x8_STORE_DEFINED
-#endif
-
-#ifndef VINT64x8_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(/* nothing */, 64, 8, 4)
-# define VINT64x8_ADD_DEFINED
-#endif
-
-#ifndef VINT64x8_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(/* nothing */, 64, 8, 4)
-# define VINT64x8_SUB_DEFINED
-#endif
-
-#ifndef VINT64x8_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(/* nothing */, 64, 8, 4)
-# define VINT64x8_MUL_DEFINED
-#endif
-
-#ifndef VINT64x8_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(/* nothing */, 64, 8, 4)
-# define VINT64x8_DIV_DEFINED
-#endif
-
-#ifndef VINT64x8_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(/* nothing */, 64, 8, 4)
-# define VINT64x8_MOD_DEFINED
-#endif
-
-#ifndef VINT64x8_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(/* nothing */, 64, 8, 4)
-# define VINT64x8_AVG_DEFINED
-#endif
-
-#ifndef VINT64x8_AND_DEFINED
-VEC_GENERIC_DBL_AND(/* nothing */, 64, 8, 4)
-# define VINT64x8_AND_DEFINED
-#endif
-
-#ifndef VINT64x8_OR_DEFINED
-VEC_GENERIC_DBL_OR(/* nothing */, 64, 8, 4)
-# define VINT64x8_OR_DEFINED
-#endif
-
-#ifndef VINT64x8_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(/* nothing */, 64, 8, 4)
-# define VINT64x8_XOR_DEFINED
-#endif
-
-#ifndef VINT64x8_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(/* nothing */, 64, 8, 4)
-# define VINT64x8_NOT_DEFINED
-#endif
-
-#ifndef VINT64x8_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(/* nothing */, 64, 8, 4)
-# define VINT64x8_CMPLT_DEFINED
-#endif
-
-#ifndef VINT64x8_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(/* nothing */, 64, 8, 4)
-# define VINT64x8_CMPEQ_DEFINED
-#endif
-
-#ifndef VINT64x8_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(/* nothing */, 64, 8, 4)
-# define VINT64x8_CMPGT_DEFINED
-#endif
-
-#ifndef VINT64x8_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(/* nothing */, 64, 8, 4)
-# define VINT64x8_CMPLE_DEFINED
-#endif
-
-#ifndef VINT64x8_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(/* nothing */, 64, 8, 4)
-# define VINT64x8_CMPGE_DEFINED
-#endif
-
-#ifndef VINT64x8_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(/* nothing */, 64, 8, 4)
-# define VINT64x8_MIN_DEFINED
-#endif
-
-#ifndef VINT64x8_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(/* nothing */, 64, 8, 4)
-# define VINT64x8_MAX_DEFINED
-#endif
-
-#ifndef VINT64x8_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(/* nothing */, 64, 8, 4)
-# define VINT64x8_RSHIFT_DEFINED
-#endif
-
-#ifndef VINT64x8_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(/* nothing */, 64, 8, 4)
-# define VINT64x8_LRSHIFT_DEFINED
-#endif
-
-#ifndef VINT64x8_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(/* nothing */, 64, 8, 4)
-# define VINT64x8_LSHIFT_DEFINED
-#endif
-
-
-
-/* vint64x8 */
-
-#ifndef VUINT64x8_SPLAT_DEFINED
-VEC_GENERIC_DBL_SPLAT(u, 64, 8, 4)
-# define VUINT64x8_SPLAT_DEFINED
-#endif
-
-#ifndef VUINT64x8_LOAD_ALIGNED_DEFINED
-VEC_GENERIC_DBL_LOAD_ALIGNED(u, 64, 8, 4)
-# define VUINT64x8_LOAD_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT64x8_LOAD_DEFINED
-VEC_GENERIC_DBL_LOAD(u, 64, 8, 4)
-# define VUINT64x8_LOAD_DEFINED
-#endif
-
-#ifndef VUINT64x8_STORE_ALIGNED_DEFINED
-VEC_GENERIC_DBL_STORE_ALIGNED(u, 64, 8, 4)
-# define VUINT64x8_STORE_ALIGNED_DEFINED
-#endif
-
-#ifndef VUINT64x8_STORE_DEFINED
-VEC_GENERIC_DBL_STORE(u, 64, 8, 4)
-# define VUINT64x8_STORE_DEFINED
-#endif
-
-#ifndef VUINT64x8_ADD_DEFINED
-VEC_GENERIC_DBL_ADD(u, 64, 8, 4)
-# define VUINT64x8_ADD_DEFINED
-#endif
-
-#ifndef VUINT64x8_SUB_DEFINED
-VEC_GENERIC_DBL_SUB(u, 64, 8, 4)
-# define VUINT64x8_SUB_DEFINED
-#endif
-
-#ifndef VUINT64x8_MUL_DEFINED
-VEC_GENERIC_DBL_MUL(u, 64, 8, 4)
-# define VUINT64x8_MUL_DEFINED
-#endif
-
-#ifndef VUINT64x8_DIV_DEFINED
-VEC_GENERIC_DBL_DIV(u, 64, 8, 4)
-# define VUINT64x8_DIV_DEFINED
-#endif
-
-#ifndef VUINT64x8_MOD_DEFINED
-VEC_GENERIC_DBL_MOD(u, 64, 8, 4)
-# define VUINT64x8_MOD_DEFINED
-#endif
-
-#ifndef VUINT64x8_AVG_DEFINED
-VEC_GENERIC_DBL_AVG(u, 64, 8, 4)
-# define VUINT64x8_AVG_DEFINED
-#endif
-
-#ifndef VUINT64x8_AND_DEFINED
-VEC_GENERIC_DBL_AND(u, 64, 8, 4)
-# define VUINT64x8_AND_DEFINED
-#endif
-
-#ifndef VUINT64x8_OR_DEFINED
-VEC_GENERIC_DBL_OR(u, 64, 8, 4)
-# define VUINT64x8_OR_DEFINED
-#endif
-
-#ifndef VUINT64x8_XOR_DEFINED
-VEC_GENERIC_DBL_XOR(u, 64, 8, 4)
-# define VUINT64x8_XOR_DEFINED
-#endif
-
-#ifndef VUINT64x8_NOT_DEFINED
-VEC_GENERIC_DBL_NOT(u, 64, 8, 4)
-# define VUINT64x8_NOT_DEFINED
-#endif
-
-#ifndef VUINT64x8_CMPLT_DEFINED
-VEC_GENERIC_DBL_CMPLT(u, 64, 8, 4)
-# define VUINT64x8_CMPLT_DEFINED
-#endif
-
-#ifndef VUINT64x8_CMPEQ_DEFINED
-VEC_GENERIC_DBL_CMPEQ(u, 64, 8, 4)
-# define VUINT64x8_CMPEQ_DEFINED
-#endif
-
-#ifndef VUINT64x8_CMPGT_DEFINED
-VEC_GENERIC_DBL_CMPGT(u, 64, 8, 4)
-# define VUINT64x8_CMPGT_DEFINED
-#endif
-
-#ifndef VUINT64x8_CMPLE_DEFINED
-VEC_GENERIC_DBL_CMPLE(u, 64, 8, 4)
-# define VUINT64x8_CMPLE_DEFINED
-#endif
-
-#ifndef VUINT64x8_CMPGE_DEFINED
-VEC_GENERIC_DBL_CMPGE(u, 64, 8, 4)
-# define VUINT64x8_CMPGE_DEFINED
-#endif
-
-#ifndef VUINT64x8_MIN_DEFINED
-VEC_GENERIC_DBL_MIN(u, 64, 8, 4)
-# define VUINT64x8_MIN_DEFINED
-#endif
-
-#ifndef VUINT64x8_MAX_DEFINED
-VEC_GENERIC_DBL_MAX(u, 64, 8, 4)
-# define VUINT64x8_MAX_DEFINED
-#endif
-
-#ifndef VUINT64x8_RSHIFT_DEFINED
-VEC_GENERIC_DBL_RSHIFT(u, 64, 8, 4)
-# define VUINT64x8_RSHIFT_DEFINED
-#endif
-
-#ifndef VUINT64x8_LRSHIFT_DEFINED
-VEC_GENERIC_DBL_LRSHIFT(u, 64, 8, 4)
-# define VUINT64x8_LRSHIFT_DEFINED
-#endif
-
-#ifndef VUINT64x8_LSHIFT_DEFINED
-VEC_GENERIC_DBL_LSHIFT(u, 64, 8, 4)
-# define VUINT64x8_LSHIFT_DEFINED
-#endif
-
 #endif /* VEC_IMPL_GENERIC_H_ */
 
diff -r 55cadb1fac4b -r c6e0df09b86f include/vec/impl/ppc/altivec.h
--- a/include/vec/impl/ppc/altivec.h	Sun Apr 27 02:49:53 2025 -0400
+++ b/include/vec/impl/ppc/altivec.h	Mon Apr 28 16:31:59 2025 -0400
@@ -22,231 +22,1116 @@
  * SOFTWARE.
 **/
 
-/* Altivec vector support. */
+/* This file is automatically generated! Do not edit it directly!
+ * Edit the code that generates it in utils/gengcc.c  --paper */
 
 #ifndef VEC_IMPL_PPC_ALTIVEC_H_
 #define VEC_IMPL_PPC_ALTIVEC_H_
 
-/* GCC 4.2.1 on Mac OS X doesn't have these for some reason */
+
+
+
+/* vuint8x16 */
+
+#ifdef vec_splats
+#ifndef VINT8x16_SPLAT_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_splat(vec_int8 x)
+{
+	vint8x16 vec;
+	vec.altivec = vec_splats(x);
+	return vec;
+}
+# define VINT8x16_SPLAT_DEFINED
+#endif
+#endif
+#ifndef VINT8x16_LOAD_ALIGNED_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_load_aligned(const vec_int8 x[16])
+{
+	vint8x16 vec;
+	vec.altivec = vec_ld(0, x);
+	return vec;
+}
+# define VINT8x16_LOAD_ALIGNED_DEFINED
+#endif
+#ifndef VINT8x16_LOAD_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_load(const vec_int8 x[16])
+{
+	vint8x16 vec;
+	vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x));
+	return vec;
+}
+# define VINT8x16_LOAD_DEFINED
+#endif
+#ifndef VINT8x16_STORE_ALIGNED_DEFINED
+VEC_FUNC_IMPL void vint8x16_store_aligned(vint8x16 vec, vec_int8 arr[16])
+{
+	vec_st(vec.altivec, 0, arr);
+}
+# define VINT8x16_STORE_ALIGNED_DEFINED
+#endif
+#ifndef VINT8x16_STORE_DEFINED
+VEC_FUNC_IMPL void vint8x16_store(vint8x16 vec, vec_int8 arr[16])
+{
+	memcpy(arr, &vec, sizeof(vec));
+}
+# define VINT8x16_STORE_DEFINED
+#endif
+#ifndef VINT8x16_ADD_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_add(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_add(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_ADD_DEFINED
+#endif
+#ifndef VINT8x16_SUB_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_sub(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_sub(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_SUB_DEFINED
+#endif
 #ifdef vec_mul
-# define VEC_ALTIVEC_DEFINE_MUL(sign, csign, bits, size) \
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_mul(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = vec_mul(vec1.altivec, vec2.altivec); \
-		return vec; \
-	}
-# define VEC_ALTIVEC_STRUCT_MUL(sign, csign, bits, size) \
-	v##sign##int##bits##x##size##_altivec_mul
-#else
-# define VEC_ALTIVEC_DEFINE_MUL(sign, csign, bits, size)
-# define VEC_ALTIVEC_STRUCT_MUL(sign, csign, bits, size) NULL
+#ifndef VINT8x16_MUL_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_mul(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_mul(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_MUL_DEFINED
+#endif
+#endif
+#ifndef VINT8x16_AND_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_and(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_and(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_AND_DEFINED
+#endif
+#ifndef VINT8x16_OR_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_or(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_or(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_OR_DEFINED
+#endif
+#ifndef VINT8x16_XOR_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_xor(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_xor(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_XOR_DEFINED
+#endif
+#ifndef VINT8x16_CMPLT_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_cmplt(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_cmplt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_CMPLT_DEFINED
+#endif
+#ifndef VINT8x16_CMPEQ_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_cmpeq(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_cmpeq(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_CMPEQ_DEFINED
+#endif
+#ifndef VINT8x16_CMPGT_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_cmpgt(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_cmpgt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_CMPGT_DEFINED
+#endif
+#ifndef VINT8x16_MIN_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_min(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_min(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_MIN_DEFINED
+#endif
+#ifndef VINT8x16_MAX_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_max(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_max(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_MAX_DEFINED
+#endif
+#ifndef VINT8x16_AVG_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_avg(vint8x16 vec1, vint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_avg(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_AVG_DEFINED
+#endif
+#ifndef VINT8x16_LSHIFT_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_lshift(vint8x16 vec1, vuint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_sl(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_LSHIFT_DEFINED
+#endif
+#ifndef VINT8x16_LRSHIFT_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_lrshift(vint8x16 vec1, vuint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = (vector signed char)vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_LRSHIFT_DEFINED
+#endif
+#ifndef VINT8x16_RSHIFT_DEFINED
+VEC_FUNC_IMPL vint8x16 vint8x16_rshift(vint8x16 vec1, vuint8x16 vec2)
+{
+	vint8x16 vec;
+	vec.altivec = vec_sra(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT8x16_RSHIFT_DEFINED
 #endif
 
+
+/* vint8x16 */
+
 #ifdef vec_splats
-# define VEC_ALTIVEC_DEFINE_SPLAT(sign, csign, bits, size) \
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_splat(vec_##sign##int##bits x) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = vec_splats(x); \
-		return vec; \
-	}
-# define VEC_ALTIVEC_STRUCT_SPLAT(sign, csign, bits, size) \
-	v##sign##int##bits##x##size##_altivec_splat
-#else
-# define VEC_ALTIVEC_DEFINE_SPLAT(sign, csign, bits, size)
-# define VEC_ALTIVEC_STRUCT_SPLAT(sign, csign, bits, size) NULL
+#ifndef VUINT8x16_SPLAT_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_splat(vec_uint8 x)
+{
+	vuint8x16 vec;
+	vec.altivec = vec_splats(x);
+	return vec;
+}
+# define VUINT8x16_SPLAT_DEFINED
+#endif
+#endif
+#ifndef VUINT8x16_LOAD_ALIGNED_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_load_aligned(const vec_uint8 x[16])
+{
+	vuint8x16 vec;
+	vec.altivec = vec_ld(0, x);
+	return vec;
+}
+# define VUINT8x16_LOAD_ALIGNED_DEFINED
+#endif
+#ifndef VUINT8x16_LOAD_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_load(const vec_uint8 x[16])
+{
+	vuint8x16 vec;
+	vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x));
+	return vec;
+}
+# define VUINT8x16_LOAD_DEFINED
+#endif
+#ifndef VUINT8x16_STORE_ALIGNED_DEFINED
+VEC_FUNC_IMPL void vuint8x16_store_aligned(vuint8x16 vec, vec_uint8 arr[16])
+{
+	vec_st(vec.altivec, 0, arr);
+}
+# define VUINT8x16_STORE_ALIGNED_DEFINED
+#endif
+#ifndef VUINT8x16_STORE_DEFINED
+VEC_FUNC_IMPL void vuint8x16_store(vuint8x16 vec, vec_uint8 arr[16])
+{
+	memcpy(arr, &vec, sizeof(vec));
+}
+# define VUINT8x16_STORE_DEFINED
+#endif
+#ifndef VUINT8x16_ADD_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_add(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_add(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_ADD_DEFINED
+#endif
+#ifndef VUINT8x16_SUB_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_sub(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_sub(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_SUB_DEFINED
+#endif
+#ifdef vec_mul
+#ifndef VUINT8x16_MUL_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_mul(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_mul(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_MUL_DEFINED
+#endif
+#endif
+#ifndef VUINT8x16_AND_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_and(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_and(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_AND_DEFINED
+#endif
+#ifndef VUINT8x16_OR_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_or(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_or(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_OR_DEFINED
+#endif
+#ifndef VUINT8x16_XOR_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_xor(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_xor(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_XOR_DEFINED
+#endif
+#ifndef VUINT8x16_CMPLT_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_cmplt(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_cmplt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_CMPLT_DEFINED
+#endif
+#ifndef VUINT8x16_CMPEQ_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_cmpeq(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_cmpeq(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_CMPEQ_DEFINED
+#endif
+#ifndef VUINT8x16_CMPGT_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_cmpgt(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_cmpgt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_CMPGT_DEFINED
+#endif
+#ifndef VUINT8x16_MIN_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_min(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_min(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_MIN_DEFINED
+#endif
+#ifndef VUINT8x16_MAX_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_max(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_max(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_MAX_DEFINED
+#endif
+#ifndef VUINT8x16_AVG_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_avg(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_avg(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_AVG_DEFINED
+#endif
+#ifndef VUINT8x16_LSHIFT_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_lshift(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_sl(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_LSHIFT_DEFINED
+#endif
+#ifndef VUINT8x16_LRSHIFT_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_lrshift(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = (vector unsigned char)vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_LRSHIFT_DEFINED
+#endif
+#ifndef VUINT8x16_RSHIFT_DEFINED
+VEC_FUNC_IMPL vuint8x16 vuint8x16_rshift(vuint8x16 vec1, vuint8x16 vec2)
+{
+	vuint8x16 vec;
+	vec.altivec = vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT8x16_RSHIFT_DEFINED
+#endif
+
+
+/* vuint16x8 */
+
+#ifdef vec_splats
+#ifndef VINT16x8_SPLAT_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_splat(vec_int16 x)
+{
+	vint16x8 vec;
+	vec.altivec = vec_splats(x);
+	return vec;
+}
+# define VINT16x8_SPLAT_DEFINED
+#endif
+#endif
+#ifndef VINT16x8_LOAD_ALIGNED_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_load_aligned(const vec_int16 x[8])
+{
+	vint16x8 vec;
+	vec.altivec = vec_ld(0, x);
+	return vec;
+}
+# define VINT16x8_LOAD_ALIGNED_DEFINED
+#endif
+#ifndef VINT16x8_LOAD_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_load(const vec_int16 x[8])
+{
+	vint16x8 vec;
+	vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x));
+	return vec;
+}
+# define VINT16x8_LOAD_DEFINED
+#endif
+#ifndef VINT16x8_STORE_ALIGNED_DEFINED
+VEC_FUNC_IMPL void vint16x8_store_aligned(vint16x8 vec, vec_int16 arr[8])
+{
+	vec_st(vec.altivec, 0, arr);
+}
+# define VINT16x8_STORE_ALIGNED_DEFINED
+#endif
+#ifndef VINT16x8_STORE_DEFINED
+VEC_FUNC_IMPL void vint16x8_store(vint16x8 vec, vec_int16 arr[8])
+{
+	memcpy(arr, &vec, sizeof(vec));
+}
+# define VINT16x8_STORE_DEFINED
+#endif
+#ifndef VINT16x8_ADD_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_add(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_add(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_ADD_DEFINED
+#endif
+#ifndef VINT16x8_SUB_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_sub(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_sub(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_SUB_DEFINED
+#endif
+#ifdef vec_mul
+#ifndef VINT16x8_MUL_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_mul(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_mul(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_MUL_DEFINED
+#endif
+#endif
+#ifndef VINT16x8_AND_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_and(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_and(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_AND_DEFINED
+#endif
+#ifndef VINT16x8_OR_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_or(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_or(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_OR_DEFINED
+#endif
+#ifndef VINT16x8_XOR_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_xor(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_xor(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_XOR_DEFINED
+#endif
+#ifndef VINT16x8_CMPLT_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_cmplt(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_cmplt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_CMPLT_DEFINED
+#endif
+#ifndef VINT16x8_CMPEQ_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_cmpeq(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_cmpeq(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_CMPEQ_DEFINED
+#endif
+#ifndef VINT16x8_CMPGT_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_cmpgt(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_cmpgt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_CMPGT_DEFINED
+#endif
+#ifndef VINT16x8_MIN_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_min(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_min(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_MIN_DEFINED
+#endif
+#ifndef VINT16x8_MAX_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_max(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_max(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_MAX_DEFINED
+#endif
+#ifndef VINT16x8_AVG_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_avg(vint16x8 vec1, vint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_avg(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_AVG_DEFINED
+#endif
+#ifndef VINT16x8_LSHIFT_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_lshift(vint16x8 vec1, vuint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_sl(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_LSHIFT_DEFINED
+#endif
+#ifndef VINT16x8_LRSHIFT_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_lrshift(vint16x8 vec1, vuint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = (vector signed short)vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_LRSHIFT_DEFINED
+#endif
+#ifndef VINT16x8_RSHIFT_DEFINED
+VEC_FUNC_IMPL vint16x8 vint16x8_rshift(vint16x8 vec1, vuint16x8 vec2)
+{
+	vint16x8 vec;
+	vec.altivec = vec_sra(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT16x8_RSHIFT_DEFINED
 #endif
 
-#define VEC_ALTIVEC_uRSHIFT vec_sr
-#define VEC_ALTIVEC_RSHIFT vec_sra
+
+/* vint16x8 */
 
-#define VEC_ALTIVEC_DEFINE_uLRSHIFT(sign, csign, bits, size) \
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_lrshift(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = vec_sr(vec1.altivec, vec2.altivec); \
-		return vec; \
-	}
-#define VEC_ALTIVEC_STRUCT_uLRSHIFT(sign, csign, bits, size) \
-	v##sign##int##bits##x##size##_altivec_lrshift
+#ifdef vec_splats
+#ifndef VUINT16x8_SPLAT_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_splat(vec_uint16 x)
+{
+	vuint16x8 vec;
+	vec.altivec = vec_splats(x);
+	return vec;
+}
+# define VUINT16x8_SPLAT_DEFINED
+#endif
+#endif
+#ifndef VUINT16x8_LOAD_ALIGNED_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_load_aligned(const vec_uint16 x[8])
+{
+	vuint16x8 vec;
+	vec.altivec = vec_ld(0, x);
+	return vec;
+}
+# define VUINT16x8_LOAD_ALIGNED_DEFINED
+#endif
+#ifndef VUINT16x8_LOAD_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_load(const vec_uint16 x[8])
+{
+	vuint16x8 vec;
+	vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x));
+	return vec;
+}
+# define VUINT16x8_LOAD_DEFINED
+#endif
+#ifndef VUINT16x8_STORE_ALIGNED_DEFINED
+VEC_FUNC_IMPL void vuint16x8_store_aligned(vuint16x8 vec, vec_uint16 arr[8])
+{
+	vec_st(vec.altivec, 0, arr);
+}
+# define VUINT16x8_STORE_ALIGNED_DEFINED
+#endif
+#ifndef VUINT16x8_STORE_DEFINED
+VEC_FUNC_IMPL void vuint16x8_store(vuint16x8 vec, vec_uint16 arr[8])
+{
+	memcpy(arr, &vec, sizeof(vec));
+}
+# define VUINT16x8_STORE_DEFINED
+#endif
+#ifndef VUINT16x8_ADD_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_add(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_add(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_ADD_DEFINED
+#endif
+#ifndef VUINT16x8_SUB_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_sub(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_sub(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_SUB_DEFINED
+#endif
+#ifdef vec_mul
+#ifndef VUINT16x8_MUL_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_mul(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_mul(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_MUL_DEFINED
+#endif
+#endif
+#ifndef VUINT16x8_AND_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_and(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_and(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_AND_DEFINED
+#endif
+#ifndef VUINT16x8_OR_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_or(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_or(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_OR_DEFINED
+#endif
+#ifndef VUINT16x8_XOR_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_xor(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_xor(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_XOR_DEFINED
+#endif
+#ifndef VUINT16x8_CMPLT_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_cmplt(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_cmplt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_CMPLT_DEFINED
+#endif
+#ifndef VUINT16x8_CMPEQ_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_cmpeq(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_cmpeq(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_CMPEQ_DEFINED
+#endif
+#ifndef VUINT16x8_CMPGT_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_cmpgt(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_cmpgt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_CMPGT_DEFINED
+#endif
+#ifndef VUINT16x8_MIN_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_min(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_min(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_MIN_DEFINED
+#endif
+#ifndef VUINT16x8_MAX_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_max(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_max(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_MAX_DEFINED
+#endif
+#ifndef VUINT16x8_AVG_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_avg(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_avg(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_AVG_DEFINED
+#endif
+#ifndef VUINT16x8_LSHIFT_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_lshift(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_sl(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_LSHIFT_DEFINED
+#endif
+#ifndef VUINT16x8_LRSHIFT_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_lrshift(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = (vector unsigned short)vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_LRSHIFT_DEFINED
+#endif
+#ifndef VUINT16x8_RSHIFT_DEFINED
+VEC_FUNC_IMPL vuint16x8 vuint16x8_rshift(vuint16x8 vec1, vuint16x8 vec2)
+{
+	vuint16x8 vec;
+	vec.altivec = vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT16x8_RSHIFT_DEFINED
+#endif
 
-#define VEC_ALTIVEC_DEFINE_LRSHIFT(sign, csign, bits, size)
-#define VEC_ALTIVEC_STRUCT_LRSHIFT(sign, csign, bits, size) NULL
 
-#define VEC_ALTIVEC_CAST_BOOL_8 (vector signed char)
-#define VEC_ALTIVEC_CAST_BOOL_U8 (vector unsigned char)
-#define VEC_ALTIVEC_CAST_BOOL_16 (vector signed short)
-#define VEC_ALTIVEC_CAST_BOOL_U16 (vector unsigned short)
-#define VEC_ALTIVEC_CAST_BOOL_32 (vector signed int)
-#define VEC_ALTIVEC_CAST_BOOL_U32 (vector unsigned int)
+/* vuint32x4 */
 
-/* Since altivec conveniently made their API super user friendly, we can just use
- * one giant macro to define literally everything */
-#define VEC_DEFINE_OPERATIONS_SIGN(sign, csign, bits, size) \
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_load_aligned(const vec_##sign##int##bits in[size]) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = vec_ld(0, in); \
-		return vec; \
-	} \
-	\
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_load(const vec_##sign##int##bits in[size]) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = vec_perm(vec_ld(0, in), vec_ld(16, in), vec_lvsl(0, in)); \
-		return vec; \
-	} \
-	\
-	static void v##sign##int##bits##x##size##_altivec_store_aligned(v##sign##int##bits##x##size vec, vec_##sign##int##bits out[size]) \
-	{ \
-		vec_st(vec.altivec, 0, out); \
-	} \
-	\
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_add(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = vec_add(vec1.altivec, vec2.altivec); \
-		return vec; \
-	} \
-	\
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_sub(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = vec_sub(vec1.altivec, vec2.altivec); \
-		return vec; \
-	} \
-	\
-	VEC_ALTIVEC_DEFINE_MUL(sign, csign, bits, size) \
-	\
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_lshift(v##sign##int##bits##x##size vec1, vuint##bits##x##size vec2) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = vec_sl(vec1.altivec, vec2.altivec); \
-		return vec; \
-	} \
-	\
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_rshift(v##sign##int##bits##x##size vec1, vuint##bits##x##size vec2) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = VEC_ALTIVEC_##sign##RSHIFT(vec1.altivec, vec2.altivec); \
-		return vec; \
-	} \
-	\
-	VEC_ALTIVEC_DEFINE_##sign##LRSHIFT(sign, csign, bits, size) \
-	\
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_avg(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = vec_avg(vec1.altivec, vec2.altivec); \
-		return vec; \
-	} \
-	\
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_and(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = vec_and(vec1.altivec, vec2.altivec); \
-		return vec; \
-	} \
-	\
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_or(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = vec_or(vec1.altivec, vec2.altivec); \
-		return vec; \
-	} \
-	\
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_xor(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = vec_xor(vec1.altivec, vec2.altivec); \
-		return vec; \
-	} \
-	\
-	VEC_ALTIVEC_DEFINE_SPLAT(sign, csign, bits, size) \
-	\
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_cmplt(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = VEC_ALTIVEC_CAST_BOOL_##csign##bits  vec_cmplt(vec1.altivec, vec2.altivec); \
-		return vec; \
-	} \
-	\
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_cmple(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = VEC_ALTIVEC_CAST_BOOL_##csign##bits vec_or(vec_cmplt(vec1.altivec, vec2.altivec), vec_cmpeq(vec1.altivec, vec2.altivec)); \
-		return vec; \
-	} \
-	\
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_cmpeq(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = VEC_ALTIVEC_CAST_BOOL_##csign##bits vec_cmpeq(vec1.altivec, vec2.altivec); \
-		return vec; \
-	} \
-	\
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_cmpge(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = VEC_ALTIVEC_CAST_BOOL_##csign##bits vec_or(vec_cmpgt(vec1.altivec, vec2.altivec), vec_cmpeq(vec1.altivec, vec2.altivec)); \
-		return vec; \
-	} \
-	\
-	static v##sign##int##bits##x##size v##sign##int##bits##x##size##_altivec_cmpgt(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \
-	{ \
-		v##sign##int##bits##x##size vec; \
-		vec.altivec = VEC_ALTIVEC_CAST_BOOL_##csign##bits vec_cmpgt(vec1.altivec, vec2.altivec); \
-		return vec; \
-	} \
-	\
-	static v##sign##int##bits##x##size##_impl v##sign##int##bits##x##size##_impl_altivec = { \
-		VEC_ALTIVEC_STRUCT_SPLAT(sign, csign, bits, size), \
-		v##sign##int##bits##x##size##_altivec_load_aligned, \
-		v##sign##int##bits##x##size##_altivec_load, \
-		v##sign##int##bits##x##size##_altivec_store_aligned, \
-		/* .store = */ NULL, \
-		v##sign##int##bits##x##size##_altivec_add, \
-		v##sign##int##bits##x##size##_altivec_sub, \
-		VEC_ALTIVEC_STRUCT_MUL(sign, csign, bits, size), \
-		/* .div = */ NULL, \
-		v##sign##int##bits##x##size##_altivec_avg, \
-		v##sign##int##bits##x##size##_altivec_and, \
-		v##sign##int##bits##x##size##_altivec_or, \
-		v##sign##int##bits##x##size##_altivec_xor, \
-		/* .not = */ NULL, \
-		v##sign##int##bits##x##size##_altivec_lshift, \
-		v##sign##int##bits##x##size##_altivec_rshift, \
-		VEC_ALTIVEC_STRUCT_##sign##LRSHIFT(sign, csign, bits, size), \
-		v##sign##int##bits##x##size##_altivec_cmplt, \
-		v##sign##int##bits##x##size##_altivec_cmple, \
-		v##sign##int##bits##x##size##_altivec_cmpeq, \
-		v##sign##int##bits##x##size##_altivec_cmpge, \
-		v##sign##int##bits##x##size##_altivec_cmpgt, \
-	};
+#ifdef vec_splats
+#ifndef VINT32x4_SPLAT_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_splat(vec_int32 x)
+{
+	vint32x4 vec;
+	vec.altivec = vec_splats(x);
+	return vec;
+}
+# define VINT32x4_SPLAT_DEFINED
+#endif
+#endif
+#ifndef VINT32x4_LOAD_ALIGNED_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_load_aligned(const vec_int32 x[4])
+{
+	vint32x4 vec;
+	vec.altivec = vec_ld(0, x);
+	return vec;
+}
+# define VINT32x4_LOAD_ALIGNED_DEFINED
+#endif
+#ifndef VINT32x4_LOAD_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_load(const vec_int32 x[4])
+{
+	vint32x4 vec;
+	vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x));
+	return vec;
+}
+# define VINT32x4_LOAD_DEFINED
+#endif
+#ifndef VINT32x4_STORE_ALIGNED_DEFINED
+VEC_FUNC_IMPL void vint32x4_store_aligned(vint32x4 vec, vec_int32 arr[4])
+{
+	vec_st(vec.altivec, 0, arr);
+}
+# define VINT32x4_STORE_ALIGNED_DEFINED
+#endif
+#ifndef VINT32x4_STORE_DEFINED
+VEC_FUNC_IMPL void vint32x4_store(vint32x4 vec, vec_int32 arr[4])
+{
+	memcpy(arr, &vec, sizeof(vec));
+}
+# define VINT32x4_STORE_DEFINED
+#endif
+#ifndef VINT32x4_ADD_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_add(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_add(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_ADD_DEFINED
+#endif
+#ifndef VINT32x4_SUB_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_sub(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_sub(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_SUB_DEFINED
+#endif
+#ifdef vec_mul
+#ifndef VINT32x4_MUL_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_mul(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_mul(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_MUL_DEFINED
+#endif
+#endif
+#ifndef VINT32x4_AND_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_and(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_and(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_AND_DEFINED
+#endif
+#ifndef VINT32x4_OR_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_or(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_or(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_OR_DEFINED
+#endif
+#ifndef VINT32x4_XOR_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_xor(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_xor(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_XOR_DEFINED
+#endif
+#ifndef VINT32x4_CMPLT_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_cmplt(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_cmplt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_CMPLT_DEFINED
+#endif
+#ifndef VINT32x4_CMPEQ_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_cmpeq(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_cmpeq(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_CMPEQ_DEFINED
+#endif
+#ifndef VINT32x4_CMPGT_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_cmpgt(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_cmpgt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_CMPGT_DEFINED
+#endif
+#ifndef VINT32x4_MIN_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_min(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_min(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_MIN_DEFINED
+#endif
+#ifndef VINT32x4_MAX_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_max(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_max(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_MAX_DEFINED
+#endif
+#ifndef VINT32x4_AVG_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_avg(vint32x4 vec1, vint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_avg(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_AVG_DEFINED
+#endif
+#ifndef VINT32x4_LSHIFT_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_lshift(vint32x4 vec1, vuint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_sl(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_LSHIFT_DEFINED
+#endif
+#ifndef VINT32x4_LRSHIFT_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_lrshift(vint32x4 vec1, vuint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = (vector signed int)vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_LRSHIFT_DEFINED
+#endif
+#ifndef VINT32x4_RSHIFT_DEFINED
+VEC_FUNC_IMPL vint32x4 vint32x4_rshift(vint32x4 vec1, vuint32x4 vec2)
+{
+	vint32x4 vec;
+	vec.altivec = vec_sra(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VINT32x4_RSHIFT_DEFINED
+#endif
+
 
-#define VEC_DEFINE_OPERATIONS(bits, size) \
-	VEC_DEFINE_OPERATIONS_SIGN( ,  , bits, size) \
-	VEC_DEFINE_OPERATIONS_SIGN(u, U, bits, size)
-
-VEC_DEFINE_OPERATIONS(8, 16)
-VEC_DEFINE_OPERATIONS(16, 8)
-VEC_DEFINE_OPERATIONS(32, 4)
-//#ifdef VEC_COMPILER_HAS_ALTIVEC_VSX
-//VEC_DEFINE_OPERATIONS(64, 2)
-//#endif
+/* vint32x4 */
 
-#undef VEC_DEFINE_OPERATIONS
-#undef VEC_DEFINE_OPERATIONS_SIGN
-#undef VEC_ALTIVEC_DEFINE_MUL
-#undef VEC_ALTIVEC_STRUCT_MUL
-#undef VEC_ALTIVEC_DEFINE_LRSHIFT
-#undef VEC_ALTIVEC_STRUCT_LRSHIFT
-#undef VEC_ALTIVEC_DEFINE_uLRSHIFT
-#undef VEC_ALTIVEC_STRUCT_uLRSHIFT
-#undef VEC_ALTIVEC_DEFINE_SPLAT
-#undef VEC_ALTIVEC_STRUCT_SPLAT
-#undef VEC_ALTIVEC_uRSHIFT
-#undef VEC_ALTIVEC_RSHIFT
+#ifdef vec_splats
+#ifndef VUINT32x4_SPLAT_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_splat(vec_uint32 x)
+{
+	vuint32x4 vec;
+	vec.altivec = vec_splats(x);
+	return vec;
+}
+# define VUINT32x4_SPLAT_DEFINED
+#endif
+#endif
+#ifndef VUINT32x4_LOAD_ALIGNED_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_load_aligned(const vec_uint32 x[4])
+{
+	vuint32x4 vec;
+	vec.altivec = vec_ld(0, x);
+	return vec;
+}
+# define VUINT32x4_LOAD_ALIGNED_DEFINED
+#endif
+#ifndef VUINT32x4_LOAD_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_load(const vec_uint32 x[4])
+{
+	vuint32x4 vec;
+	vec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x));
+	return vec;
+}
+# define VUINT32x4_LOAD_DEFINED
+#endif
+#ifndef VUINT32x4_STORE_ALIGNED_DEFINED
+VEC_FUNC_IMPL void vuint32x4_store_aligned(vuint32x4 vec, vec_uint32 arr[4])
+{
+	vec_st(vec.altivec, 0, arr);
+}
+# define VUINT32x4_STORE_ALIGNED_DEFINED
+#endif
+#ifndef VUINT32x4_STORE_DEFINED
+VEC_FUNC_IMPL void vuint32x4_store(vuint32x4 vec, vec_uint32 arr[4])
+{
+	memcpy(arr, &vec, sizeof(vec));
+}
+# define VUINT32x4_STORE_DEFINED
+#endif
+#ifndef VUINT32x4_ADD_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_add(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_add(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_ADD_DEFINED
+#endif
+#ifndef VUINT32x4_SUB_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_sub(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_sub(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_SUB_DEFINED
+#endif
+#ifdef vec_mul
+#ifndef VUINT32x4_MUL_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_mul(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_mul(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_MUL_DEFINED
+#endif
+#endif
+#ifndef VUINT32x4_AND_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_and(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_and(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_AND_DEFINED
+#endif
+#ifndef VUINT32x4_OR_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_or(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_or(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_OR_DEFINED
+#endif
+#ifndef VUINT32x4_XOR_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_xor(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_xor(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_XOR_DEFINED
+#endif
+#ifndef VUINT32x4_CMPLT_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_cmplt(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_cmplt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_CMPLT_DEFINED
+#endif
+#ifndef VUINT32x4_CMPEQ_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_cmpeq(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_cmpeq(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_CMPEQ_DEFINED
+#endif
+#ifndef VUINT32x4_CMPGT_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_cmpgt(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_cmpgt(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_CMPGT_DEFINED
+#endif
+#ifndef VUINT32x4_MIN_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_min(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_min(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_MIN_DEFINED
+#endif
+#ifndef VUINT32x4_MAX_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_max(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_max(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_MAX_DEFINED
+#endif
+#ifndef VUINT32x4_AVG_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_avg(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_avg(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_AVG_DEFINED
+#endif
+#ifndef VUINT32x4_LSHIFT_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_lshift(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_sl(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_LSHIFT_DEFINED
+#endif
+#ifndef VUINT32x4_LRSHIFT_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_lrshift(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = (vector unsigned int)vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_LRSHIFT_DEFINED
+#endif
+#ifndef VUINT32x4_RSHIFT_DEFINED
+VEC_FUNC_IMPL vuint32x4 vuint32x4_rshift(vuint32x4 vec1, vuint32x4 vec2)
+{
+	vuint32x4 vec;
+	vec.altivec = vec_sr(vec1.altivec, vec2.altivec);
+	return vec;
+}
+# define VUINT32x4_RSHIFT_DEFINED
+#endif
+#endif /* VEC_IMPL_PPC_ALTIVEC_H_ */
 
-#endif /* VEC_IMPL_PPC_ALTIVEC_H_ */
diff -r 55cadb1fac4b -r c6e0df09b86f include/vec/vec.h
--- a/include/vec/vec.h	Sun Apr 27 02:49:53 2025 -0400
+++ b/include/vec/vec.h	Mon Apr 28 16:31:59 2025 -0400
@@ -355,7 +355,7 @@
 	return xx.d;
 }
 
-VEC_FUNC_IMPL vec_intmax vec_avg(vec_intmax x, vec_intmax y)
+VEC_FUNC_IMPL vec_intmax vec_imavg(vec_intmax x, vec_intmax y)
 {
 	vec_intmax x_d_rem    = (x % 2);
 	vec_intmax y_d_rem    = (y % 2);
@@ -365,7 +365,7 @@
 	return ((x / 2) + (y / 2)) + (rem_d_quot) + (rem_d_rem == 1);
 }
 
-VEC_FUNC_IMPL vec_uintmax vec_uavg(vec_uintmax x, vec_uintmax y)
+VEC_FUNC_IMPL vec_uintmax vec_imuavg(vec_uintmax x, vec_uintmax y)
 {
 	return (x >> 1) + (y >> 1) + ((x | y) & 1);
 }
@@ -1031,7 +1031,7 @@
 } vint64x8;
 
 /* ------------------------------------------------------------------------ */
-/* finally; we can import the real implementations */
+/* x86 */
 
 #ifdef VEC_COMPILER_HAS_AVX512BW
 # include "impl/x86/avx512bw.h"
@@ -1061,11 +1061,31 @@
 # include "impl/x86/mmx.h"
 #endif
 
+/* ------------------------------------------------------------------------ */
+/* PowerPC */
+
+#ifdef VEC_COMPILER_HAS_ALTIVEC
+# include "impl/ppc/altivec.h"
+#endif
+
+/* ------------------------------------------------------------------------ */
+/* By this point, if we've defined native intrinsics, we'll just want to
+ * double them, rather than use GCC extensions.
+ * In particular with very old GCC, it can generate very bad asm that
+ * can perform even worse than non-vectorized code. */
+
+#include "impl/double.h"
+
+/* ------------------------------------------------------------------------ */
+/* Use GCC's vector extensions, if available. */
+
 #ifdef VEC_COMPILER_HAS_GCC_VECTORS
 # include "impl/gcc.h"
 #endif
 
+/* Fill in anything remaining with a generic array-based implementation. */
 #include "impl/generic.h"
+#include "impl/double.h"
 
 /* ------------------------------------------------------------------------ */
 
diff -r 55cadb1fac4b -r c6e0df09b86f test/Makefile.ppc
--- a/test/Makefile.ppc	Sun Apr 27 02:49:53 2025 -0400
+++ b/test/Makefile.ppc	Mon Apr 28 16:31:59 2025 -0400
@@ -1,3 +1,4 @@
 CPPFLAGS += -maltivec
+LDFLAGS += -maltivec
 
-include Makefile.template
\ No newline at end of file
+include Makefile.template
diff -r 55cadb1fac4b -r c6e0df09b86f test/Makefile.template
--- a/test/Makefile.template	Sun Apr 27 02:49:53 2025 -0400
+++ b/test/Makefile.template	Mon Apr 28 16:31:59 2025 -0400
@@ -1,4 +1,4 @@
-CPPFLAGS += -g -O2 -I../include -Wall -Wpedantic -Werror=strict-aliasing
+CPPFLAGS += -g -O2 -I../include -Wall
 CFLAGS += $(CPPFLAGS) -std=c99
 CXXFLAGS += $(CPPFLAGS) -std=c++11
 
diff -r 55cadb1fac4b -r c6e0df09b86f test/test.c
--- a/test/test.c	Sun Apr 27 02:49:53 2025 -0400
+++ b/test/test.c	Mon Apr 28 16:31:59 2025 -0400
@@ -111,10 +111,12 @@
 
 // ------------------------------------------------------------
 
+#if 0
 #include "test_align.h"
 #include "test_arith.h"
 #include "test_compare.h"
 #include "test_shift.h"
+#endif
 #include "test_benchmark.h"
 
 // ------------------------------------------------------------
@@ -125,10 +127,12 @@
 
 	srand(time(NULL));
 
+#if 0
 	ret |= test_align();
 	ret |= test_arith();
 	ret |= test_compare();
 	ret |= test_shift();
+#endif
 
 	test_benchmark();
 
diff -r 55cadb1fac4b -r c6e0df09b86f test/test_arith.h
--- a/test/test_arith.h	Sun Apr 27 02:49:53 2025 -0400
+++ b/test/test_arith.h	Mon Apr 28 16:31:59 2025 -0400
@@ -40,7 +40,7 @@
 	CREATE_TEST(sign, psign, csign, bits, size, and, orig_a[i] & orig_b[i]) \
 	CREATE_TEST(sign, psign, csign, bits, size, or,  orig_a[i] | orig_b[i]) \
 	CREATE_TEST(sign, psign, csign, bits, size, xor, orig_a[i] ^ orig_b[i]) \
-	CREATE_TEST(sign, psign, csign, bits, size, avg, (vec_##sign##int##bits)vec_##sign##avg(orig_a[i], orig_b[i])) \
+	CREATE_TEST(sign, psign, csign, bits, size, avg, (vec_##sign##int##bits)vec_im##sign##avg(orig_a[i], orig_b[i])) \
 	CREATE_TEST_SHIFT(sign, psign, csign, bits, size, rshift, vec_##sign##rshift(orig_a[i], orig_b[i])) \
 	CREATE_TEST_SHIFT(sign, psign, csign, bits, size, lshift, vec_##sign##lshift(orig_a[i], orig_b[i])) \
 	CREATE_TEST_SHIFT(sign, psign, csign, bits, size, lrshift, vec_urshift((vec_uint##bits)orig_a[i], orig_b[i])) \
diff -r 55cadb1fac4b -r c6e0df09b86f test/test_benchmark.h
--- a/test/test_benchmark.h	Sun Apr 27 02:49:53 2025 -0400
+++ b/test/test_benchmark.h	Mon Apr 28 16:31:59 2025 -0400
@@ -14,12 +14,8 @@
 
 	printf("\nsigned 16-bit audio sample min/max - 1 thousand passes - 16000001 samples\n\n");
 
-	/* generate random sample values */
-	for (i = 0; i < 16000001; i++)
-		q[i] = rand();
-
 	start = clock();
-	for (i = 0; i < 1000; i++) {
+	for (i = 0; i < 100; i++) {
 		min = INT32_MAX;
 		max = INT32_MIN;
 		test_benchmark_sample_minmax_vec_impl(q, 16000001u, &min, &max);
@@ -29,7 +25,7 @@
 	printf("- vec: took %f secs\n", (double)(end - start) / CLOCKS_PER_SEC);
 
 	start = clock();
-	for (i = 0; i < 1000; i++) {
+	for (i = 0; i < 100; i++) {
 		min = INT32_MAX;
 		max = INT32_MIN;
 		test_benchmark_sample_minmax_simple_impl(q, 16000001u, &min, &max);
diff -r 55cadb1fac4b -r c6e0df09b86f test/test_benchmark_vec.c
--- a/test/test_benchmark_vec.c	Sun Apr 27 02:49:53 2025 -0400
+++ b/test/test_benchmark_vec.c	Mon Apr 28 16:31:59 2025 -0400
@@ -6,31 +6,31 @@
 	int32_t smin = INT32_MAX, smax = INT32_MIN;
 	uint32_t len32;
 	int i;
-	vint16x32 min = vint16x32_splat(*pmin);
-	vint16x32 max = vint16x32_splat(*pmax);
-	VINT16x32_ALIGNED_ARRAY(mins);
-	VINT16x32_ALIGNED_ARRAY(maxs);
+	vint16x8 min = vint16x8_splat(*pmin);
+	vint16x8 max = vint16x8_splat(*pmax);
+	VINT16x8_ALIGNED_ARRAY(mins);
+	VINT16x8_ALIGNED_ARRAY(maxs);
 
-	len32 = length / 32;
+	len32 = length / 8;
 	while (len32--) {
-		vint16x32 vec = vint16x32_load_aligned(smpl);
+		vint16x8 vec = vint16x8_load_aligned(smpl);
 
-		min = vint16x32_min(vec, min);
-		max = vint16x32_max(vec, max);
+		min = vint16x8_min(vec, min);
+		max = vint16x8_max(vec, max);
 
-		smpl += 32;
+		smpl += 8;
 	}
 
-	vint16x32_store_aligned(min, mins);
-	vint16x32_store_aligned(max, maxs);
+	vint16x8_store_aligned(min, mins);
+	vint16x8_store_aligned(max, maxs);
 
 	/* get the lowest minimum of what we have left */
-	for (i = 0; i < 32; i++) {
+	for (i = 0; i < 8; i++) {
 		if (mins[i] < smin) smin = mins[i];
 		if (maxs[i] > smax) smax = maxs[i];
 	}
 
-	len32 = length % 32;
+	len32 = length % 8;
 	while (len32--) {
 		if (*smpl < smin) smin = *smpl;
 		if (*smpl > smax) smax = *smpl;
diff -r 55cadb1fac4b -r c6e0df09b86f utils/genaltivec.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/utils/genaltivec.c	Mon Apr 28 16:31:59 2025 -0400
@@ -0,0 +1,374 @@
+/**
+ * vec - a tiny SIMD vector library in C99
+ * 
+ * Copyright (c) 2024-2025 Paper
+ * 
+ * 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.
+**/
+
+/* Use this file to generate include/vec/impl/ppc/altivec.h !!
+ *
+ * `gcc -o genaltivec genaltivec.c` */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
+
+/* ------------------------------------------------------------------------ */
+
+/* #define USE_VSX_EXTENSIONS */
+
+enum op {
+	/* return vector, take in a integer */
+	OP_SPLAT = 0,
+
+	/* return vector, take in an array */
+	OP_LOAD_ALIGNED,
+	OP_LOAD,
+
+	/* void, take in vector and array */
+	OP_STORE_ALIGNED,
+	OP_STORE,
+
+	/* return vector, takes in two vectors */
+	OP_ADD,
+	OP_SUB,
+	OP_MUL,
+	OP_AND,
+	OP_OR,
+	OP_XOR,
+	OP_CMPLT,
+	OP_CMPEQ,
+	OP_CMPGT,
+#ifdef USE_VSX_EXTENSIONS
+	OP_CMPLE,
+	OP_CMPGE,
+#endif
+	OP_MIN,
+	OP_MAX,
+	OP_AVG,
+
+	/* return vector, takes in a vector and an explicitly unsigned vector */
+	OP_LSHIFT,
+	OP_LRSHIFT,
+	OP_RSHIFT,
+
+	OP_FINAL_,
+
+	/* unimplemented, no altivec version :) */
+	OP_NOT,
+};
+
+/* convert op -> string */
+static struct {
+	const char *u;
+	const char *l;
+} op_names[] = {
+	[OP_SPLAT] = {"SPLAT", "splat"},
+	[OP_LOAD_ALIGNED] = {"LOAD_ALIGNED", "load_aligned"},
+	[OP_LOAD] = {"LOAD", "load"},
+	[OP_STORE_ALIGNED] = {"STORE_ALIGNED", "store_aligned"},
+	[OP_STORE] = {"STORE", "store"},
+	[OP_ADD] = {"ADD", "add"},
+	[OP_SUB] = {"SUB", "sub"},
+	[OP_MUL] = {"MUL", "mul"},
+	[OP_AVG] = {"AVG", "avg"},
+	[OP_AND] = {"AND", "and"},
+	[OP_OR] = {"OR", "or"},
+	[OP_XOR] = {"XOR", "xor"},
+	[OP_NOT] = {"NOT", "not"},
+	[OP_CMPLT] = {"CMPLT", "cmplt"},
+	[OP_CMPEQ] = {"CMPEQ", "cmpeq"},
+	[OP_CMPGT] = {"CMPGT", "cmpgt"},
+#ifdef USE_VSX_EXTENSIONS
+	[OP_CMPLE] = {"CMPLE", "cmple"},
+	[OP_CMPGE] = {"CMPGE", "cmpge"},
+#endif
+	[OP_MIN] = {"MIN", "min"},
+	[OP_MAX] = {"MAX", "max"},
+	[OP_RSHIFT] = {"RSHIFT", "rshift"},
+	[OP_LRSHIFT] = {"LRSHIFT", "lrshift"},
+	[OP_LSHIFT] = {"LSHIFT", "lshift"},
+};
+
+#define UPSIGN(x) ((x) ? "" : "U")
+#define LOSIGN(x) ((x) ? "" : "u")
+
+static void print_gcc_op(enum op op, int is_signed, int bits, int size)
+{
+	int i;
+
+	/* compatibility with ancient gcc */
+	switch (op) {
+	case OP_MUL:
+		puts("#ifdef vec_mul");
+		break;
+	case OP_SPLAT:
+		puts("#ifdef vec_splats");
+		break;
+	default:
+		break;
+	}
+
+	printf("#ifndef V%sINT%dx%d_%s_DEFINED\n", UPSIGN(is_signed), bits, size, op_names[op].u);
+
+	printf("VEC_FUNC_IMPL ");
+
+	/* first; the return value */
+	switch (op) {
+	case OP_SPLAT:
+	case OP_LOAD_ALIGNED:
+	case OP_LOAD:
+	case OP_ADD:
+	case OP_SUB:
+	case OP_MUL:
+	case OP_AND:
+	case OP_OR:
+	case OP_XOR:
+	case OP_CMPLT:
+	case OP_CMPEQ:
+	case OP_CMPGT:
+#ifdef USE_VSX_EXTENSIONS
+	case OP_CMPLE:
+	case OP_CMPGE:
+#endif
+	case OP_MIN:
+	case OP_MAX:
+	case OP_AVG:
+	case OP_RSHIFT:
+	case OP_LRSHIFT:
+	case OP_LSHIFT:
+	case OP_NOT:
+		printf("v%sint%dx%d", LOSIGN(is_signed), bits, size);
+		break;
+	case OP_STORE_ALIGNED:
+	case OP_STORE:
+		printf("void");
+		break;
+	}
+
+	/* whitespace and function name */
+	printf(" v%sint%dx%d_%s(", LOSIGN(is_signed), bits, size, op_names[op].l);
+
+	/* parameters */
+	switch (op) {
+	case OP_SPLAT:
+		printf("vec_%sint%d x", LOSIGN(is_signed), bits);
+		break;
+	case OP_LOAD_ALIGNED:
+	case OP_LOAD:
+		printf("const vec_%sint%d x[%d]", LOSIGN(is_signed), bits, size);
+		break;
+	case OP_STORE_ALIGNED:
+	case OP_STORE:
+		printf("v%sint%dx%d vec, vec_%sint%d arr[%d]", LOSIGN(is_signed), bits, size, LOSIGN(is_signed), bits, size);
+		break;
+	case OP_ADD:
+	case OP_SUB:
+	case OP_MUL:
+	case OP_AND:
+	case OP_OR:
+	case OP_XOR:
+	case OP_CMPLT:
+	case OP_CMPEQ:
+	case OP_CMPGT:
+#ifdef USE_VSX_EXTENSIONS
+	case OP_CMPLE:
+	case OP_CMPGE:
+#endif
+	case OP_MIN:
+	case OP_MAX:
+	case OP_AVG:
+		printf("v%sint%dx%d vec1, v%sint%dx%d vec2", LOSIGN(is_signed), bits, size, LOSIGN(is_signed), bits, size);
+		break;
+	case OP_RSHIFT:
+	case OP_LRSHIFT:
+	case OP_LSHIFT:
+		printf("v%sint%dx%d vec1, vuint%dx%d vec2", LOSIGN(is_signed), bits, size, bits, size);
+		break;
+	case OP_NOT:
+		printf("v%sint%dx%d vec", LOSIGN(is_signed), bits, size);
+		break;
+	}
+
+	puts(")\n{");
+
+	switch (op) {
+	case OP_SPLAT:
+		printf("\tv%sint%dx%d vec;\n", LOSIGN(is_signed), bits, size);
+		printf("\tvec.altivec = vec_splats(x);\n");
+		printf("\treturn vec;\n");
+		break;
+	case OP_LOAD_ALIGNED:
+		printf("\tv%sint%dx%d vec;\n", LOSIGN(is_signed), bits, size);
+		puts("\tvec.altivec = vec_ld(0, x);");
+		printf("\treturn vec;\n");
+		break;
+	case OP_LOAD:
+		printf("\tv%sint%dx%d vec;\n", LOSIGN(is_signed), bits, size);
+		puts("\tvec.altivec = vec_perm(vec_ld(0, x), vec_ld(16, x), vec_lvsl(0, x));");
+		printf("\treturn vec;\n");
+		break;
+	case OP_STORE_ALIGNED:
+		puts("\tvec_st(vec.altivec, 0, arr);");
+		break;
+	case OP_STORE:
+		/* ??? */
+		puts("\tmemcpy(arr, &vec, sizeof(vec));");
+		break;
+	case OP_ADD:
+	case OP_SUB:
+	case OP_MUL:
+	case OP_AND:
+	case OP_OR:
+	case OP_XOR:
+	case OP_AVG:
+	case OP_CMPLT:
+	case OP_CMPEQ:
+	case OP_CMPGT:
+#ifdef USE_VSX_EXTENSIONS
+	case OP_CMPLE:
+	case OP_CMPGE:
+#endif
+	case OP_LSHIFT:
+	case OP_LRSHIFT:
+	case OP_RSHIFT:
+	case OP_MIN:
+	case OP_MAX: {
+		static const char *op_altivec[OP_LRSHIFT - OP_ADD + 1] = {"add", "sub", "mul", "and", "or", "xor", "cmplt", "cmpeq", "cmpgt",
+#ifdef USE_VSX_EXTENSIONS
+			"cmple",
+			"cmpge",
+#endif
+			"min", "max", "avg", "sl", "sr"};
+		static const char *types[] = {"char", "short", NULL, "int"};
+
+		printf("\tv%sint%dx%d vec;\n", LOSIGN(is_signed), bits, size);
+		if (op == OP_RSHIFT) {
+			printf("\tvec.altivec = vec_sr%s(vec1.altivec, vec2.altivec);\n", (is_signed) ? "a" : "");
+		} else {
+			printf("\tvec.altivec = (vector %s %s)vec_%s(vec1.altivec, vec2.altivec);\n", (is_signed) ? "signed" : "unsigned", types[(bits / 8) - 1], op_altivec[op - OP_ADD]);
+		}
+		printf("\treturn vec;\n");
+		break;
+	}
+	default:
+		printf("#error implement this operation");
+		break;
+	}
+
+	/* end function definition */
+	puts("}");
+
+	printf("# define V%sINT%dx%d_%s_DEFINED\n", UPSIGN(is_signed), bits, size, op_names[op].u);
+	puts("#endif");
+
+	switch (op) {
+	case OP_SPLAT:
+	case OP_MUL:
+		puts("#endif");
+		break;
+	default:
+		break;
+	}
+}
+
+static inline void print_ops(int is_signed, int bits, int size)
+{
+	int i;
+
+	printf("\n\n/* v%sint%dx%d */\n\n", (is_signed ? "u" : ""), bits, size);
+
+	for (i = 0; i < OP_FINAL_; i++)
+		print_gcc_op(i, is_signed, bits, size);
+}
+
+#ifdef USE_VSX_EXTENSIONS
+# define HEADER_GUARD_NAME "VSX"
+#else
+# define HEADER_GUARD_NAME "ALTIVEC"
+#endif
+
+static const char *header =
+	"/**\n"
+	" * vec - a tiny SIMD vector library in C99\n"
+	" * \n"
+	" * Copyright (c) 2024-2025 Paper\n"
+	" * \n"
+	" * Permission is hereby granted, free of charge, to any person obtaining a copy\n"
+	" * of this software and associated documentation files (the \"Software\"), to deal\n"
+	" * in the Software without restriction, including without limitation the rights\n"
+	" * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n"
+	" * copies of the Software, and to permit persons to whom the Software is\n"
+	" * furnished to do so, subject to the following conditions:\n"
+	" * \n"
+	" * The above copyright notice and this permission notice shall be included in all\n"
+	" * copies or substantial portions of the Software.\n"
+	" * \n"
+	" * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
+	" * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
+	" * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n"
+	" * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n"
+	" * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n"
+	" * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n"
+	" * SOFTWARE.\n"
+	"**/\n"
+	"\n"
+	"/* This file is automatically generated! Do not edit it directly!\n"
+	" * Edit the code that generates it in utils/genaltivec.c  --paper */\n"
+	"\n"
+	"#ifndef VEC_IMPL_PPC_" HEADER_GUARD_NAME "_H_\n"
+	"#define VEC_IMPL_PPC_" HEADER_GUARD_NAME "_H_\n"
+	"\n";
+
+static const char *footer = 
+	"#endif /* VEC_IMPL_PPC_" HEADER_GUARD_NAME "_H_ */\n";
+
+int main(void)
+{
+	static struct {
+		int bits, size;
+	} defs[] = {
+		/* -- 8-bit */
+		{8, 16},
+		/* -- 16-bit */
+		{16, 8},
+
+		/* -- 32-bit */
+		{32, 4},
+
+#ifdef USE_VSX_EXTENSIONS
+		/* -- 64-bit */
+		{64, 2},
+#endif
+	};
+	int i;
+
+	puts(header);
+
+	for (i = 0; i < ARRAY_SIZE(defs); i++) {
+		print_ops(1, defs[i].bits, defs[i].size);
+		print_ops(0, defs[i].bits, defs[i].size);
+	}
+
+	puts(footer);
+}
diff -r 55cadb1fac4b -r c6e0df09b86f utils/gendouble.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/utils/gendouble.c	Mon Apr 28 16:31:59 2025 -0400
@@ -0,0 +1,244 @@
+/**
+ * vec - a tiny SIMD vector library in C99
+ * 
+ * Copyright (c) 2024-2025 Paper
+ * 
+ * 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.
+**/
+
+/* Use this file to generate include/vec/impl/double.h !!
+ *
+ * `gcc -o gendouble gendouble.c` */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
+
+/* XXX: would it be faster to unroll literally everything instead of defining everything,
+ * and then unpacking it all? */
+static const char *header =
+	"/**\n"
+	" * vec - a tiny SIMD vector library in C99\n"
+	" * \n"
+	" * Copyright (c) 2024-2025 Paper\n"
+	" * \n"
+	" * Permission is hereby granted, free of charge, to any person obtaining a copy\n"
+	" * of this software and associated documentation files (the \"Software\"), to deal\n"
+	" * in the Software without restriction, including without limitation the rights\n"
+	" * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n"
+	" * copies of the Software, and to permit persons to whom the Software is\n"
+	" * furnished to do so, subject to the following conditions:\n"
+	" * \n"
+	" * The above copyright notice and this permission notice shall be included in all\n"
+	" * copies or substantial portions of the Software.\n"
+	" * \n"
+	" * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
+	" * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
+	" * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n"
+	" * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n"
+	" * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n"
+	" * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n"
+	" * SOFTWARE.\n"
+	"**/\n"
+	"\n"
+	"/* This file is automatically generated! Do not edit it directly!\n"
+	" * Edit the code that generates it in utils/gengeneric.c  --paper */\n"
+	"\n"
+	"#ifndef VEC_IMPL_DOUBLE_H_\n"
+	"#define VEC_IMPL_DOUBLE_H_\n"
+	"\n"
+	"#define VEC_DOUBLE_SPLAT(sign, bits, size, halfsize) \\\n"
+	"	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_splat(vec_##sign##int##bits x) \\\n"
+	"	{ \\\n"
+	"		v##sign##int##bits##x##size vec; \\\n"
+	"	\\\n"
+	"		vec.generic[0] = v##sign##int##bits##x##halfsize##_splat(x); \\\n"
+	"		vec.generic[1] = v##sign##int##bits##x##halfsize##_splat(x); \\\n"
+	"	\\\n"
+	"		return vec; \\\n"
+	"	}\n"
+	"\n"
+	"#define VEC_DOUBLE_LOAD_EX(name, sign, bits, size, halfsize) \\\n"
+	"	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_##name(const vec_##sign##int##bits x[size]) \\\n"
+	"	{ \\\n"
+	"		v##sign##int##bits##x##size vec; \\\n"
+	"	\\\n"
+	"		vec.generic[0] = v##sign##int##bits##x##halfsize##_##name(x); \\\n"
+	"		vec.generic[1] = v##sign##int##bits##x##halfsize##_##name(x + halfsize); \\\n"
+	"	\\\n"
+	"		return vec; \\\n"
+	"	}\n"
+	"\n"
+	"#define VEC_DOUBLE_LOAD(sign, bits, size, halfsize) VEC_DOUBLE_LOAD_EX(load, sign, bits, size, halfsize)\n"
+	"#define VEC_DOUBLE_LOAD_ALIGNED(sign, bits, size, halfsize) VEC_DOUBLE_LOAD_EX(load_aligned, sign, bits, size, halfsize)\n"
+	"\n"
+	"#define VEC_DOUBLE_STORE_EX(name, sign, bits, size, halfsize) \\\n"
+	"	VEC_FUNC_IMPL void v##sign##int##bits##x##size##_##name(v##sign##int##bits##x##size vec, vec_##sign##int##bits x[size]) \\\n"
+	"	{ \\\n"
+	"		v##sign##int##bits##x##halfsize##_##name(vec.generic[0], x); \\\n"
+	"		v##sign##int##bits##x##halfsize##_##name(vec.generic[1], x + halfsize); \\\n"
+	"	}\n"
+	"\n"
+	"#define VEC_DOUBLE_STORE(sign, bits, size, halfsize) VEC_DOUBLE_STORE_EX(store, sign, bits, size, halfsize)\n"
+	"#define VEC_DOUBLE_STORE_ALIGNED(sign, bits, size, halfsize) VEC_DOUBLE_STORE_EX(store_aligned, sign, bits, size, halfsize)\n"
+	"\n"
+	"#define VEC_DOUBLE_OP(name, sign, bits, size, halfsize, secondsign) \\\n"
+	"	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_##name(v##sign##int##bits##x##size vec1, v##secondsign##int##bits##x##size vec2) \\\n"
+	"	{ \\\n"
+	"		vec1.generic[0] = v##sign##int##bits##x##halfsize##_##name(vec1.generic[0], vec2.generic[0]); \\\n"
+	"		vec1.generic[1] = v##sign##int##bits##x##halfsize##_##name(vec1.generic[1], vec2.generic[1]); \\\n"
+	"	\\\n"
+	"		return vec1; \\\n"
+	"	}\n"
+	"\n"
+	"#define VEC_DOUBLE_ADD(sign, bits, size, halfsize) VEC_DOUBLE_OP(add, sign, bits, size, halfsize, sign)\n"
+	"#define VEC_DOUBLE_SUB(sign, bits, size, halfsize) VEC_DOUBLE_OP(sub, sign, bits, size, halfsize, sign)\n"
+	"#define VEC_DOUBLE_MUL(sign, bits, size, halfsize) VEC_DOUBLE_OP(mul, sign, bits, size, halfsize, sign)\n"
+	"#define VEC_DOUBLE_DIV(sign, bits, size, halfsize) VEC_DOUBLE_OP(div, sign, bits, size, halfsize, sign)\n"
+	"#define VEC_DOUBLE_MOD(sign, bits, size, halfsize) VEC_DOUBLE_OP(mod, sign, bits, size, halfsize, sign)\n"
+	"#define VEC_DOUBLE_AVG(sign, bits, size, halfsize) VEC_DOUBLE_OP(avg, sign, bits, size, halfsize, sign)\n"
+	"#define VEC_DOUBLE_LSHIFT(sign, bits, size, halfsize) VEC_DOUBLE_OP(lshift, sign, bits, size, halfsize, u)\n"
+	"#define VEC_DOUBLE_RSHIFT(sign, bits, size, halfsize) VEC_DOUBLE_OP(rshift, sign, bits, size, halfsize, u)\n"
+	"#define VEC_DOUBLE_LRSHIFT(sign, bits, size, halfsize) VEC_DOUBLE_OP(lrshift, sign, bits, size, halfsize, u)\n"
+	"#define VEC_DOUBLE_AND(sign, bits, size, halfsize) VEC_DOUBLE_OP(and, sign, bits, size, halfsize, sign)\n"
+	"#define VEC_DOUBLE_OR(sign, bits, size, halfsize) VEC_DOUBLE_OP(or, sign, bits, size, halfsize, sign)\n"
+	"#define VEC_DOUBLE_XOR(sign, bits, size, halfsize) VEC_DOUBLE_OP(xor, sign, bits, size, halfsize, sign)\n"
+	"#define VEC_DOUBLE_MIN(sign, bits, size, halfsize) VEC_DOUBLE_OP(min, sign, bits, size, halfsize, sign)\n"
+	"#define VEC_DOUBLE_MAX(sign, bits, size, halfsize) VEC_DOUBLE_OP(max, sign, bits, size, halfsize, sign)\n"
+	"#define VEC_DOUBLE_CMPLT(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmplt, sign, bits, size, halfsize, sign)\n"
+	"#define VEC_DOUBLE_CMPLE(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmple, sign, bits, size, halfsize, sign)\n"
+	"#define VEC_DOUBLE_CMPEQ(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmpeq, sign, bits, size, halfsize, sign)\n"
+	"#define VEC_DOUBLE_CMPGE(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmpge, sign, bits, size, halfsize, sign)\n"
+	"#define VEC_DOUBLE_CMPGT(sign, bits, size, halfsize) VEC_DOUBLE_OP(cmpgt, sign, bits, size, halfsize, sign)\n"
+	"\n"
+	"#define VEC_DOUBLE_NOT(sign, bits, size, halfsize) \\\n"
+	"	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_not(v##sign##int##bits##x##size vec) \\\n"
+	"	{ \\\n"
+	"		vec.generic[0] = v##sign##int##bits##x##halfsize##_not(vec.generic[0]); \\\n"
+	"		vec.generic[1] = v##sign##int##bits##x##halfsize##_not(vec.generic[1]); \\\n"
+	"	\\\n"
+	"		return vec; \\\n"
+	"	}\n"
+	"\n"
+	"#endif /* VEC_IMPL_DOUBLE_H_ */ \n"
+	"\n"
+	"/* ------------------------------------------------------------------------ */\n"
+	"/* PREPROCESSOR HELL INCOMING */\n"
+	"";
+
+static const char *footer = 
+	"" /* nothing */;
+
+/* ------------------------------------------------------------------------ */
+
+static void print_generic_dbl_op(const char *op, int is_signed, int bits, int size)
+{
+	printf(
+		"#if !defined(V%sINT%dx%d_%s_DEFINED) && defined(V%sINT%dx%d_%s_DEFINED)\n"
+		"VEC_DOUBLE_%s(%s, %d, %d, %d)\n"
+		"# define V%sINT%dx%d_%s_DEFINED\n"
+		"#endif\n\n",
+	(is_signed ? "" : "U"), bits, size, op, (is_signed ? "" : "U"), bits, size / 2, op,
+	op, (is_signed ? "/* nothing */" : "u"), bits, size, size / 2,
+	(is_signed ? "" : "U"), bits, size, op);
+}
+
+typedef void (*print_op_spec)(const char *op, int is_signed, int bits, int size);
+
+static inline void print_ops(int is_signed, int bits, int size, print_op_spec print_op)
+{
+	/* all supported operations here */
+	static const char *ops[] = {
+		"SPLAT",
+		"LOAD_ALIGNED",
+		"LOAD",
+		"STORE_ALIGNED",
+		"STORE",
+		"ADD",
+		"SUB",
+		"MUL",
+		"DIV",
+		"MOD",
+		"AVG",
+		"AND",
+		"OR",
+		"XOR",
+		"NOT",
+		"CMPLT",
+		"CMPEQ",
+		"CMPGT",
+		"CMPLE", /* these two must be after CMPLT and CMPGT respectfully, */
+		"CMPGE", /* because their definitions call those functions */
+		"MIN",
+		"MAX",
+		"RSHIFT",
+		"LRSHIFT",
+		"LSHIFT",
+		NULL,
+	};
+	int i;
+
+	printf("\n\n/* v%sint%dx%d */\n\n", (is_signed ? "u" : ""), bits, size);
+
+	for (i = 0; ops[i]; i++)
+		print_op(ops[i], is_signed, bits, size);
+}
+
+int main(void)
+{
+	static struct {
+		int bits, size;
+		print_op_spec print_op;
+	} defs[] = {
+		/* -- 8-bit */
+		{8, 4, print_generic_dbl_op},
+		{8, 8, print_generic_dbl_op},
+		{8, 16, print_generic_dbl_op},
+		{8, 32, print_generic_dbl_op},
+		{8, 64, print_generic_dbl_op},
+
+		/* -- 16-bit */
+		{16, 4, print_generic_dbl_op},
+		{16, 8, print_generic_dbl_op},
+		{16, 16, print_generic_dbl_op},
+		{16, 32, print_generic_dbl_op},
+
+		/* -- 32-bit */
+		{32, 4, print_generic_dbl_op},
+		{32, 8, print_generic_dbl_op},
+		{32, 16, print_generic_dbl_op},
+
+		/* -- 64-bit */
+		{64, 4, print_generic_dbl_op},
+		{64, 8, print_generic_dbl_op},
+	};
+	int i;
+
+	puts(header);
+
+	for (i = 0; i < ARRAY_SIZE(defs); i++) {
+		print_ops(1, defs[i].bits, defs[i].size, defs[i].print_op);
+		print_ops(0, defs[i].bits, defs[i].size, defs[i].print_op);
+	}
+
+	puts(footer);
+}
diff -r 55cadb1fac4b -r c6e0df09b86f utils/gengcc.c
--- a/utils/gengcc.c	Sun Apr 27 02:49:53 2025 -0400
+++ b/utils/gengcc.c	Mon Apr 28 16:31:59 2025 -0400
@@ -119,7 +119,27 @@
 static void print_gcc_op(enum op op, int is_signed, int bits, int size)
 {
 	int i;
+	int gccprereq = 0;
 
+	switch (op) {
+	case OP_CMPEQ:
+	case OP_CMPLE:
+	case OP_CMPLT:
+	case OP_CMPGT:
+	case OP_CMPGE:
+	case OP_MIN:
+	case OP_MAX:
+	case OP_LSHIFT:
+	case OP_RSHIFT:
+	case OP_LRSHIFT:
+	case OP_AVG:
+		puts("#if VEC_GNUC_ATLEAST(4, 3, 0)");
+		gccprereq = 1;
+		break;
+	default:
+		break;
+	}
+	
 	printf("#ifndef V%sINT%dx%d_%s_DEFINED\n", UPSIGN(is_signed), bits, size, op_names[op].u);
 
 	printf("VEC_FUNC_IMPL ");
@@ -271,16 +291,17 @@
 		break;
 	}
 	case OP_AVG:
+		printf("\tvint%dx%d ones = vint%dx%d_splat(1);\n", bits, size, bits, size);
+
 		if (is_signed) {
-			printf("\tvint%dx%d ones = vint%dx%d_splat(1);\n", bits, size, bits, size);
-			printf("\t__typeof__(vec1.gcc) x_d_rem = (vec1.gcc % 2);\n");
-			printf("\t__typeof__(vec1.gcc) y_d_rem = (vec2.gcc % 2);\n");
-			printf("\t__typeof__(vec1.gcc) rem_d_quot = ((x_d_rem + y_d_rem) / 2);\n");
-			printf("\t__typeof__(vec1.gcc) rem_d_rem = ((x_d_rem + y_d_rem) % 2);\n");
+			puts("\t__typeof__(vec1.gcc) x_d_rem = (vec1.gcc % 2);");
+			puts("\t__typeof__(vec1.gcc) y_d_rem = (vec2.gcc % 2);");
+			puts("\t__typeof__(vec1.gcc) rem_d_quot = ((x_d_rem + y_d_rem) / 2);");
+			puts("\t__typeof__(vec1.gcc) rem_d_rem = ((x_d_rem + y_d_rem) % 2);");
 			puts("");
 			printf("\tvec1.gcc = ((vec1.gcc / 2) + (vec2.gcc / 2)) + (rem_d_quot) + ((rem_d_rem == 1) & ones.gcc);\n");
 		} else {
-			printf("\tvec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & 1);\n");
+			printf("\tvec1.gcc = (vec1.gcc >> 1) + (vec2.gcc >> 1) + ((vec1.gcc | vec2.gcc) & ones.gcc);\n");
 		}
 
 		printf("\treturn vec1;\n");
@@ -299,6 +320,9 @@
 
 	printf("# define V%sINT%dx%d_%s_DEFINED\n", UPSIGN(is_signed), bits, size, op_names[op].u);
 	puts("#endif");
+
+	if (gccprereq)
+		puts("#endif");
 }
 
 static inline void print_ops(int is_signed, int bits, int size)
diff -r 55cadb1fac4b -r c6e0df09b86f utils/gengeneric.c
--- a/utils/gengeneric.c	Sun Apr 27 02:49:53 2025 -0400
+++ b/utils/gengeneric.c	Mon Apr 28 16:31:59 2025 -0400
@@ -147,7 +147,7 @@
 	"	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_avg(v##sign##int##bits##x##size vec1, v##sign##int##bits##x##size vec2) \\\n"
 	"	{ \\\n"
 	"		for (int i = 0; i < size; i++) \\\n"
-	"			vec1.generic[i] = vec_##sign##avg(vec1.generic[i], vec2.generic[i]); \\\n"
+	"			vec1.generic[i] = vec_im##sign##avg(vec1.generic[i], vec2.generic[i]); \\\n"
 	"	\\\n"
 	"		return vec1; \\\n"
 	"	}\n"
@@ -246,79 +246,6 @@
 	"		return v##sign##int##bits##x##size##_or(a, b); \\\n"
 	"	}\n"
 	"\n"
-	"#define VEC_GENERIC_DBL_SPLAT(sign, bits, size, halfsize) \\\n"
-	"	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_splat(vec_##sign##int##bits x) \\\n"
-	"	{ \\\n"
-	"		v##sign##int##bits##x##size vec; \\\n"
-	"	\\\n"
-	"		vec.generic[0] = v##sign##int##bits##x##halfsize##_splat(x); \\\n"
-	"		vec.generic[1] = v##sign##int##bits##x##halfsize##_splat(x); \\\n"
-	"	\\\n"
-	"		return vec; \\\n"
-	"	}\n"
-	"\n"
-	"#define VEC_GENERIC_DBL_LOAD_EX(name, sign, bits, size, halfsize) \\\n"
-	"	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_##name(const vec_##sign##int##bits x[size]) \\\n"
-	"	{ \\\n"
-	"		v##sign##int##bits##x##size vec; \\\n"
-	"	\\\n"
-	"		vec.generic[0] = v##sign##int##bits##x##halfsize##_##name(x); \\\n"
-	"		vec.generic[1] = v##sign##int##bits##x##halfsize##_##name(x + halfsize); \\\n"
-	"	\\\n"
-	"		return vec; \\\n"
-	"	}\n"
-	"\n"
-	"#define VEC_GENERIC_DBL_LOAD(sign, bits, size, halfsize) VEC_GENERIC_DBL_LOAD_EX(load, sign, bits, size, halfsize)\n"
-	"#define VEC_GENERIC_DBL_LOAD_ALIGNED(sign, bits, size, halfsize) VEC_GENERIC_DBL_LOAD_EX(load_aligned, sign, bits, size, halfsize)\n"
-	"\n"
-	"#define VEC_GENERIC_DBL_STORE_EX(name, sign, bits, size, halfsize) \\\n"
-	"	VEC_FUNC_IMPL void v##sign##int##bits##x##size##_##name(v##sign##int##bits##x##size vec, vec_##sign##int##bits x[size]) \\\n"
-	"	{ \\\n"
-	"		v##sign##int##bits##x##halfsize##_##name(vec.generic[0], x); \\\n"
-	"		v##sign##int##bits##x##halfsize##_##name(vec.generic[1], x + halfsize); \\\n"
-	"	}\n"
-	"\n"
-	"#define VEC_GENERIC_DBL_STORE(sign, bits, size, halfsize) VEC_GENERIC_DBL_STORE_EX(store, sign, bits, size, halfsize)\n"
-	"#define VEC_GENERIC_DBL_STORE_ALIGNED(sign, bits, size, halfsize) VEC_GENERIC_DBL_STORE_EX(store_aligned, sign, bits, size, halfsize)\n"
-	"\n"
-	"#define VEC_GENERIC_DBL_OP(name, sign, bits, size, halfsize, secondsign) \\\n"
-	"	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_##name(v##sign##int##bits##x##size vec1, v##secondsign##int##bits##x##size vec2) \\\n"
-	"	{ \\\n"
-	"		vec1.generic[0] = v##sign##int##bits##x##halfsize##_##name(vec1.generic[0], vec2.generic[0]); \\\n"
-	"		vec1.generic[1] = v##sign##int##bits##x##halfsize##_##name(vec1.generic[1], vec2.generic[1]); \\\n"
-	"	\\\n"
-	"		return vec1; \\\n"
-	"	}\n"
-	"\n"
-	"#define VEC_GENERIC_DBL_ADD(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(add, sign, bits, size, halfsize, sign)\n"
-	"#define VEC_GENERIC_DBL_SUB(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(sub, sign, bits, size, halfsize, sign)\n"
-	"#define VEC_GENERIC_DBL_MUL(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(mul, sign, bits, size, halfsize, sign)\n"
-	"#define VEC_GENERIC_DBL_DIV(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(div, sign, bits, size, halfsize, sign)\n"
-	"#define VEC_GENERIC_DBL_MOD(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(mod, sign, bits, size, halfsize, sign)\n"
-	"#define VEC_GENERIC_DBL_AVG(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(avg, sign, bits, size, halfsize, sign)\n"
-	"#define VEC_GENERIC_DBL_LSHIFT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(lshift, sign, bits, size, halfsize, u)\n"
-	"#define VEC_GENERIC_DBL_RSHIFT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(rshift, sign, bits, size, halfsize, u)\n"
-	"#define VEC_GENERIC_DBL_LRSHIFT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(lrshift, sign, bits, size, halfsize, u)\n"
-	"#define VEC_GENERIC_DBL_AND(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(and, sign, bits, size, halfsize, sign)\n"
-	"#define VEC_GENERIC_DBL_OR(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(or, sign, bits, size, halfsize, sign)\n"
-	"#define VEC_GENERIC_DBL_XOR(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(xor, sign, bits, size, halfsize, sign)\n"
-	"#define VEC_GENERIC_DBL_MIN(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(min, sign, bits, size, halfsize, sign)\n"
-	"#define VEC_GENERIC_DBL_MAX(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(max, sign, bits, size, halfsize, sign)\n"
-	"#define VEC_GENERIC_DBL_CMPLT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmplt, sign, bits, size, halfsize, sign)\n"
-	"#define VEC_GENERIC_DBL_CMPLE(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmple, sign, bits, size, halfsize, sign)\n"
-	"#define VEC_GENERIC_DBL_CMPEQ(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmpeq, sign, bits, size, halfsize, sign)\n"
-	"#define VEC_GENERIC_DBL_CMPGE(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmpge, sign, bits, size, halfsize, sign)\n"
-	"#define VEC_GENERIC_DBL_CMPGT(sign, bits, size, halfsize) VEC_GENERIC_DBL_OP(cmpgt, sign, bits, size, halfsize, sign)\n"
-	"\n"
-	"#define VEC_GENERIC_DBL_NOT(sign, bits, size, halfsize) \\\n"
-	"	VEC_FUNC_IMPL v##sign##int##bits##x##size v##sign##int##bits##x##size##_not(v##sign##int##bits##x##size vec) \\\n"
-	"	{ \\\n"
-	"		vec.generic[0] = v##sign##int##bits##x##halfsize##_not(vec.generic[0]); \\\n"
-	"		vec.generic[1] = v##sign##int##bits##x##halfsize##_not(vec.generic[1]); \\\n"
-	"	\\\n"
-	"		return vec; \\\n"
-	"	}\n"
-	"\n"
 	"/* ------------------------------------------------------------------------ */\n"
 	"/* PREPROCESSOR HELL INCOMING */\n";
 
@@ -337,16 +264,6 @@
 	(is_signed ? "" : "U"), bits, size, op, op, (is_signed ? "/* nothing */" : "u"), bits, size, (is_signed ? "" : "U"), bits, size, op);
 }
 
-static void print_generic_dbl_op(const char *op, int is_signed, int bits, int size)
-{
-	printf(
-		"#ifndef V%sINT%dx%d_%s_DEFINED\n"
-		"VEC_GENERIC_DBL_%s(%s, %d, %d, %d)\n"
-		"# define V%sINT%dx%d_%s_DEFINED\n"
-		"#endif\n\n",
-	(is_signed ? "" : "U"), bits, size, op, op, (is_signed ? "/* nothing */" : "u"), bits, size, size / 2, (is_signed ? "" : "U"), bits, size, op);
-}
-
 typedef void (*print_op_spec)(const char *op, int is_signed, int bits, int size);
 
 static inline void print_ops(int is_signed, int bits, int size, print_op_spec print_op)
@@ -396,29 +313,15 @@
 	} defs[] = {
 		/* -- 8-bit */
 		{8, 2, print_generic_op},
-		{8, 4, print_generic_dbl_op},
-		{8, 8, print_generic_dbl_op},
-		{8, 16, print_generic_dbl_op},
-		{8, 32, print_generic_dbl_op},
-		{8, 64, print_generic_dbl_op},
 
 		/* -- 16-bit */
 		{16, 2, print_generic_op},
-		{16, 4, print_generic_dbl_op},
-		{16, 8, print_generic_dbl_op},
-		{16, 16, print_generic_dbl_op},
-		{16, 32, print_generic_dbl_op},
 
 		/* -- 32-bit */
 		{32, 2, print_generic_op},
-		{32, 4, print_generic_dbl_op},
-		{32, 8, print_generic_dbl_op},
-		{32, 16, print_generic_dbl_op},
 
 		/* -- 64-bit */
 		{64, 2, print_generic_op},
-		{64, 4, print_generic_dbl_op},
-		{64, 8, print_generic_dbl_op},
 	};
 	int i;